/*
 * Copyright (c) 2023-2025 elsfs Authors. All Rights Reserved.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.elsfs.cloud.common.mybatis.ext.sql;

import java.util.Collection;
import java.util.function.Consumer;
import org.elsfs.cloud.common.mybatis.ext.sql.support.builder.StandardSelectSql;

/**
 * SQL条件接口
 *
 * @param <C> 子类具体类型
 */
@SuppressWarnings("unchecked")
public interface Condition<C extends Condition<C>> extends SqlFragment {

  /**
   * 相等条件
   *
   * @param leftField 左边字段名称
   * @param rightField 右边字段名称
   * @return 具体实现
   */
  C eq(String leftField, String rightField);

  /**
   * 相等条件
   *
   * @param leftField 左边字段枚举
   * @param rightField 右边字段枚举
   * @return 具体实现
   */
  C eq(Enum<?> leftField, Enum<?> rightField);

  /**
   * 相等条件
   *
   * @param leftTableAlias 左边字段表别名
   * @param leftField 左边字段枚举
   * @param rightTableAlias 右边字段表别名
   * @param rightField 右边字段枚举
   * @return 具体实现
   */
  C eq(String leftTableAlias, Enum<?> leftField, String rightTableAlias, Enum<?> rightField);

  /**
   * 相等条件
   *
   * @param leftTableAlias 左边字段表别名
   * @param leftField 左边字段枚举
   * @param rightField 右边字段枚举
   * @return 具体实现
   */
  C eq(String leftTableAlias, Enum<?> leftField, Enum<?> rightField);

  /**
   * 相等条件
   *
   * @param leftField 左边字段枚举
   * @param rightTableAlias 右边字段表别名
   * @param rightField 右边字段枚举
   * @return 具体实现
   */
  C eq(Enum<?> leftField, String rightTableAlias, Enum<?> rightField);

  /**
   * 相等条件
   *
   * @param leftField 左边字段名称
   * @param rightField 右边字段枚举
   * @return 具体实现
   */
  C eq(String leftField, Enum<?> rightField);

  /**
   * 相等条件
   *
   * @param leftField 左边字段名称
   * @param rightTableAlias 右边字段表别名
   * @param rightField 右边字段枚举
   * @return 具体实现
   */
  C eq(String leftField, String rightTableAlias, Enum<?> rightField);

  /**
   * 相等条件
   *
   * @param leftField 左边字段枚举
   * @param rightField 右边字段名称
   * @return 具体实现
   */
  C eq(Enum<?> leftField, String rightField);

  /**
   * 相等条件
   *
   * @param leftTableAlias 左边字段表别名
   * @param leftField 左边字段枚举
   * @param rightField 右边字段名称
   * @return 具体实现
   */
  C eq(String leftTableAlias, Enum<?> leftField, String rightField);

  /**
   * 相等条件
   *
   * @param leftField 左边字段名称
   * @param sqlBuilderConsumer SQL构建器消费器
   * @return 具体实现
   */
  C eq(String leftField, Consumer<StandardSelectSql> sqlBuilderConsumer);

  /**
   * 相等条件
   *
   * @param leftField 左边字段枚举
   * @param sqlBuilderConsumer SQL构建器消费器
   * @return 具体实现
   */
  C eq(Enum<?> leftField, Consumer<StandardSelectSql> sqlBuilderConsumer);

  /**
   * 相等条件
   *
   * @param leftTableAlias 左边字段表别名
   * @param leftField 左边字段枚举
   * @param sqlBuilderConsumer SQL构建器消费器
   * @return 具体实现
   */
  C eq(String leftTableAlias, Enum<?> leftField, Consumer<StandardSelectSql> sqlBuilderConsumer);

  /**
   * 相等条件
   *
   * @param condition 条件
   * @param leftField 左边字段名称
   * @param rightField 右边字段名称
   * @return 具体实现
   */
  default C eq(boolean condition, String leftField, String rightField) {
    if (condition) {
      return this.eq(leftField, rightField);
    }

    return (C) this;
  }

  /**
   * 相等条件
   *
   * @param condition 条件
   * @param leftField 左边字段枚举
   * @param rightField 右边字段枚举
   * @return 具体实现
   */
  default C eq(boolean condition, Enum<?> leftField, Enum<?> rightField) {
    if (condition) {
      return this.eq(leftField, rightField);
    }

    return (C) this;
  }

  /**
   * 相等条件
   *
   * @param condition 条件
   * @param leftTableAlias 左边字段表别名
   * @param leftField 左边字段枚举
   * @param rightTableAlias 右边字段表别名
   * @param rightField 右边字段枚举
   * @return 具体实现
   */
  default C eq(
      boolean condition,
      String leftTableAlias,
      Enum<?> leftField,
      String rightTableAlias,
      Enum<?> rightField) {
    if (condition) {
      return this.eq(leftTableAlias, leftField, rightTableAlias, rightField);
    }

    return (C) this;
  }

  /**
   * 相等条件
   *
   * @param condition 条件
   * @param leftTableAlias 左边字段表别名
   * @param leftField 左边字段枚举
   * @param rightField 右边字段枚举
   * @return 具体实现
   */
  default C eq(boolean condition, String leftTableAlias, Enum<?> leftField, Enum<?> rightField) {
    if (condition) {
      return this.eq(leftTableAlias, leftField, rightField);
    }

    return (C) this;
  }

  /**
   * 相等条件
   *
   * @param condition 条件
   * @param leftField 左边字段枚举
   * @param rightTableAlias 右边字段表别名
   * @param rightField 右边字段枚举
   * @return 具体实现
   */
  default C eq(boolean condition, Enum<?> leftField, String rightTableAlias, Enum<?> rightField) {
    if (condition) {
      return this.eq(leftField, rightTableAlias, rightField);
    }

    return (C) this;
  }

  /**
   * 相等条件
   *
   * @param condition 条件
   * @param leftField 左边字段名称
   * @param rightField 右边字段枚举
   * @return 具体实现
   */
  default C eq(boolean condition, String leftField, Enum<?> rightField) {
    if (condition) {
      return this.eq(leftField, rightField);
    }

    return (C) this;
  }

  /**
   * 相等条件
   *
   * @param condition 条件
   * @param leftField 左边字段名称
   * @param rightTableAlias 右边字段表别名
   * @param rightField 右边字段枚举
   * @return 具体实现
   */
  default C eq(boolean condition, String leftField, String rightTableAlias, Enum<?> rightField) {
    if (condition) {
      return this.eq(leftField, rightTableAlias, rightField);
    }

    return (C) this;
  }

  /**
   * 相等条件
   *
   * @param condition 条件
   * @param leftField 左边字段枚举
   * @param rightField 右边字段名称
   * @return 具体实现
   */
  default C eq(boolean condition, Enum<?> leftField, String rightField) {
    if (condition) {
      return this.eq(leftField, rightField);
    }

    return (C) this;
  }

  /**
   * 相等条件
   *
   * @param condition 条件
   * @param leftTableAlias 左边字段表别名
   * @param leftField 左边字段枚举
   * @param rightField 右边字段名称
   * @return 具体实现
   */
  default C eq(boolean condition, String leftTableAlias, Enum<?> leftField, String rightField) {
    if (condition) {
      return this.eq(leftTableAlias, leftField, rightField);
    }

    return (C) this;
  }

  /**
   * 相等条件
   *
   * @param condition 条件
   * @param leftField 左边字段名称
   * @param sqlBuilderConsumer SQL构建器消费器
   * @return 具体实现
   */
  default C eq(
      boolean condition, String leftField, Consumer<StandardSelectSql> sqlBuilderConsumer) {
    if (condition) {
      return this.eq(leftField, sqlBuilderConsumer);
    }

    return (C) this;
  }

  /**
   * 相等条件
   *
   * @param condition 条件
   * @param leftField 左边字段枚举
   * @param sqlBuilderConsumer SQL构建器消费器
   * @return 具体实现
   */
  default C eq(
      boolean condition, Enum<?> leftField, Consumer<StandardSelectSql> sqlBuilderConsumer) {
    if (condition) {
      return this.eq(leftField, sqlBuilderConsumer);
    }

    return (C) this;
  }

  /**
   * 相等条件
   *
   * @param condition 条件
   * @param leftTableAlias 左边字段表别名
   * @param leftField 左边字段枚举
   * @param sqlBuilderConsumer SQL构建器消费器
   * @return 具体实现
   */
  default C eq(
      boolean condition,
      String leftTableAlias,
      Enum<?> leftField,
      Consumer<StandardSelectSql> sqlBuilderConsumer) {
    if (condition) {
      return this.eq(leftTableAlias, leftField, sqlBuilderConsumer);
    }

    return (C) this;
  }

  /**
   * 相等条件
   *
   * @param leftField 左边字段名称
   * @param rightValue 右边值
   * @return 具体实现
   */
  C eqValue(String leftField, Object rightValue);

  /**
   * 相等条件
   *
   * @param leftField 左边字段枚举
   * @param rightValue 右边值
   * @return 具体实现
   */
  C eqValue(Enum<?> leftField, Object rightValue);

  /**
   * 相等条件
   *
   * @param leftTableAlias 左边字段表别名
   * @param leftField 左边字段枚举
   * @param rightValue 右边值
   * @return 具体实现
   */
  C eqValue(String leftTableAlias, Enum<?> leftField, Object rightValue);

  /**
   * 相等条件
   *
   * @param condition 条件
   * @param leftField 左边字段名称
   * @param rightValue 右边值
   * @return 具体实现
   */
  default C eqValue(boolean condition, String leftField, Object rightValue) {
    if (condition) {
      return this.eqValue(leftField, rightValue);
    }

    return (C) this;
  }

  /**
   * 相等条件
   *
   * @param condition 条件
   * @param leftField 左边字段枚举
   * @param rightValue 右边值
   * @return 具体实现
   */
  default C eqValue(boolean condition, Enum<?> leftField, Object rightValue) {
    if (condition) {
      return this.eqValue(leftField, rightValue);
    }

    return (C) this;
  }

  /**
   * 相等条件
   *
   * @param condition 条件
   * @param leftTableAlias 左边字段表别名
   * @param leftField 左边字段枚举
   * @param rightValue 右边值
   * @return 具体实现
   */
  default C eqValue(
      boolean condition, String leftTableAlias, Enum<?> leftField, Object rightValue) {
    if (condition) {
      return this.eqValue(leftTableAlias, leftField, rightValue);
    }

    return (C) this;
  }

  /**
   * 不相等条件
   *
   * @param leftField 左边字段名称
   * @param rightField 右边字段名称
   * @return 具体实现
   */
  C ne(String leftField, String rightField);

  /**
   * 不相等条件
   *
   * @param leftField 左边字段枚举
   * @param rightField 右边字段枚举
   * @return 具体实现
   */
  C ne(Enum<?> leftField, Enum<?> rightField);

  /**
   * 不相等条件
   *
   * @param leftTableAlias 左边字段表别名
   * @param leftField 左边字段枚举
   * @param rightTableAlias 右边字段表别名
   * @param rightField 右边字段枚举
   * @return 具体实现
   */
  C ne(String leftTableAlias, Enum<?> leftField, String rightTableAlias, Enum<?> rightField);

  /**
   * 不相等条件
   *
   * @param leftTableAlias 左边字段表别名
   * @param leftField 左边字段枚举
   * @param rightField 右边字段枚举
   * @return 具体实现
   */
  C ne(String leftTableAlias, Enum<?> leftField, Enum<?> rightField);

  /**
   * 不相等条件
   *
   * @param leftField 左边字段枚举
   * @param rightTableAlias 右边字段表别名
   * @param rightField 右边字段枚举
   * @return 具体实现
   */
  C ne(Enum<?> leftField, String rightTableAlias, Enum<?> rightField);

  /**
   * 不相等条件
   *
   * @param leftField 左边字段名称
   * @param rightField 右边字段枚举
   * @return 具体实现
   */
  C ne(String leftField, Enum<?> rightField);

  /**
   * 不相等条件
   *
   * @param leftField 左边字段名称
   * @param rightTableAlias 右边字段表别名
   * @param rightField 右边字段枚举
   * @return 具体实现
   */
  C ne(String leftField, String rightTableAlias, Enum<?> rightField);

  /**
   * 不相等条件
   *
   * @param leftField 左边字段枚举
   * @param rightField 右边字段名称
   * @return 具体实现
   */
  C ne(Enum<?> leftField, String rightField);

  /**
   * 不相等条件
   *
   * @param leftTableAlias 左边字段表别名
   * @param leftField 左边字段枚举
   * @param rightField 右边字段名称
   * @return 具体实现
   */
  C ne(String leftTableAlias, Enum<?> leftField, String rightField);

  /**
   * 不相等条件
   *
   * @param leftField 左边字段名称
   * @param sqlBuilderConsumer SQL构建器消费器
   * @return 具体实现
   */
  C ne(String leftField, Consumer<StandardSelectSql> sqlBuilderConsumer);

  /**
   * 不相等条件
   *
   * @param leftField 左边字段枚举
   * @param sqlBuilderConsumer SQL构建器消费器
   * @return 具体实现
   */
  C ne(Enum<?> leftField, Consumer<StandardSelectSql> sqlBuilderConsumer);

  /**
   * 不相等条件
   *
   * @param leftTableAlias 左边字段表别名
   * @param leftField 左边字段枚举
   * @param sqlBuilderConsumer SQL构建器消费器
   * @return 具体实现
   */
  C ne(String leftTableAlias, Enum<?> leftField, Consumer<StandardSelectSql> sqlBuilderConsumer);

  /**
   * 不相等条件
   *
   * @param condition 条件
   * @param leftField 左边字段名称
   * @param rightField 右边字段名称
   * @return 具体实现
   */
  default C ne(boolean condition, String leftField, String rightField) {
    if (condition) {
      return this.ne(leftField, rightField);
    }

    return (C) this;
  }

  /**
   * 不相等条件
   *
   * @param condition 条件
   * @param leftField 左边字段枚举
   * @param rightField 右边字段枚举
   * @return 具体实现
   */
  default C ne(boolean condition, Enum<?> leftField, Enum<?> rightField) {
    if (condition) {
      return this.ne(leftField, rightField);
    }

    return (C) this;
  }

  /**
   * 不相等条件
   *
   * @param condition 条件
   * @param leftTableAlias 左边字段表别名
   * @param leftField 左边字段枚举
   * @param rightTableAlias 右边字段表别名
   * @param rightField 右边字段枚举
   * @return 具体实现
   */
  default C ne(
      boolean condition,
      String leftTableAlias,
      Enum<?> leftField,
      String rightTableAlias,
      Enum<?> rightField) {
    if (condition) {
      return this.ne(leftTableAlias, leftField, rightTableAlias, rightField);
    }

    return (C) this;
  }

  /**
   * 不相等条件
   *
   * @param condition 条件
   * @param leftTableAlias 左边字段表别名
   * @param leftField 左边字段枚举
   * @param rightField 右边字段枚举
   * @return 具体实现
   */
  default C ne(boolean condition, String leftTableAlias, Enum<?> leftField, Enum<?> rightField) {
    if (condition) {
      return this.ne(leftTableAlias, leftField, rightField);
    }

    return (C) this;
  }

  /**
   * 不相等条件
   *
   * @param condition 条件
   * @param leftField 左边字段枚举
   * @param rightTableAlias 右边字段表别名
   * @param rightField 右边字段枚举
   * @return 具体实现
   */
  default C ne(boolean condition, Enum<?> leftField, String rightTableAlias, Enum<?> rightField) {
    if (condition) {
      return this.ne(leftField, rightTableAlias, rightField);
    }

    return (C) this;
  }

  /**
   * 不相等条件
   *
   * @param condition 条件
   * @param leftField 左边字段名称
   * @param rightField 右边字段枚举
   * @return 具体实现
   */
  default C ne(boolean condition, String leftField, Enum<?> rightField) {
    if (condition) {
      return this.ne(leftField, rightField);
    }

    return (C) this;
  }

  /**
   * 不相等条件
   *
   * @param condition 条件
   * @param leftField 左边字段名称
   * @param rightTableAlias 右边字段表别名
   * @param rightField 右边字段枚举
   * @return 具体实现
   */
  default C ne(boolean condition, String leftField, String rightTableAlias, Enum<?> rightField) {
    if (condition) {
      return this.ne(leftField, rightTableAlias, rightField);
    }

    return (C) this;
  }

  /**
   * 不相等条件
   *
   * @param condition 条件
   * @param leftField 左边字段枚举
   * @param rightField 右边字段名称
   * @return 具体实现
   */
  default C ne(boolean condition, Enum<?> leftField, String rightField) {
    if (condition) {
      return this.ne(leftField, rightField);
    }

    return (C) this;
  }

  /**
   * 不相等条件
   *
   * @param condition 条件
   * @param leftTableAlias 左边字段表别名
   * @param leftField 左边字段枚举
   * @param rightField 右边字段名称
   * @return 具体实现
   */
  default C ne(boolean condition, String leftTableAlias, Enum<?> leftField, String rightField) {
    if (condition) {
      return this.ne(leftTableAlias, leftField, rightField);
    }

    return (C) this;
  }

  /**
   * 不相等条件
   *
   * @param condition 条件
   * @param leftField 左边字段名称
   * @param sqlBuilderConsumer SQL构建器消费器
   * @return 具体实现
   */
  default C ne(
      boolean condition, String leftField, Consumer<StandardSelectSql> sqlBuilderConsumer) {
    if (condition) {
      return this.ne(leftField, sqlBuilderConsumer);
    }

    return (C) this;
  }

  /**
   * 不相等条件
   *
   * @param condition 条件
   * @param leftField 左边字段枚举
   * @param sqlBuilderConsumer SQL构建器消费器
   * @return 具体实现
   */
  default C ne(
      boolean condition, Enum<?> leftField, Consumer<StandardSelectSql> sqlBuilderConsumer) {
    if (condition) {
      return this.ne(leftField, sqlBuilderConsumer);
    }

    return (C) this;
  }

  /**
   * 不相等条件
   *
   * @param condition 条件
   * @param leftTableAlias 左边字段表别名
   * @param leftField 左边字段枚举
   * @param sqlBuilderConsumer SQL构建器消费器
   * @return 具体实现
   */
  default C ne(
      boolean condition,
      String leftTableAlias,
      Enum<?> leftField,
      Consumer<StandardSelectSql> sqlBuilderConsumer) {
    if (condition) {
      return this.ne(leftTableAlias, leftField, sqlBuilderConsumer);
    }

    return (C) this;
  }

  /**
   * 不相等条件
   *
   * @param leftField 左边字段名称
   * @param rightValue 右边值
   * @return 具体实现
   */
  C neValue(String leftField, Object rightValue);

  /**
   * 不相等条件
   *
   * @param leftField 左边字段枚举
   * @param rightValue 右边值
   * @return 具体实现
   */
  C neValue(Enum<?> leftField, Object rightValue);

  /**
   * 不相等条件
   *
   * @param leftTableAlias 左边字段表别名
   * @param leftField 左边字段枚举
   * @param rightValue 右边值
   * @return 具体实现
   */
  C neValue(String leftTableAlias, Enum<?> leftField, Object rightValue);

  /**
   * 不相等条件
   *
   * @param condition 条件
   * @param leftField 左边字段名称
   * @param rightValue 右边值
   * @return 具体实现
   */
  default C neValue(boolean condition, String leftField, Object rightValue) {
    if (condition) {
      return this.neValue(leftField, rightValue);
    }

    return (C) this;
  }

  /**
   * 不相等条件
   *
   * @param condition 条件
   * @param leftField 左边字段枚举
   * @param rightValue 右边值
   * @return 具体实现
   */
  default C neValue(boolean condition, Enum<?> leftField, Object rightValue) {
    if (condition) {
      return this.neValue(leftField, rightValue);
    }

    return (C) this;
  }

  /**
   * 不相等条件
   *
   * @param condition 条件
   * @param leftTableAlias 左边字段表别名
   * @param leftField 左边字段枚举
   * @param rightValue 右边值
   * @return 具体实现
   */
  default C neValue(
      boolean condition, String leftTableAlias, Enum<?> leftField, Object rightValue) {
    if (condition) {
      return this.neValue(leftTableAlias, leftField, rightValue);
    }

    return (C) this;
  }

  /**
   * 小于条件
   *
   * @param leftField 左边字段名称
   * @param rightField 右边字段名称
   * @return 具体实现
   */
  C lt(String leftField, String rightField);

  /**
   * 小于条件
   *
   * @param leftField 左边字段枚举
   * @param rightField 右边字段枚举
   * @return 具体实现
   */
  C lt(Enum<?> leftField, Enum<?> rightField);

  /**
   * 小于条件
   *
   * @param leftTableAlias 左边字段表别名
   * @param leftField 左边字段枚举
   * @param rightTableAlias 右边字段表别名
   * @param rightField 右边字段枚举
   * @return 具体实现
   */
  C lt(String leftTableAlias, Enum<?> leftField, String rightTableAlias, Enum<?> rightField);

  /**
   * 小于条件
   *
   * @param leftTableAlias 左边字段表别名
   * @param leftField 左边字段枚举
   * @param rightField 右边字段枚举
   * @return 具体实现
   */
  C lt(String leftTableAlias, Enum<?> leftField, Enum<?> rightField);

  /**
   * 小于条件
   *
   * @param leftField 左边字段枚举
   * @param rightTableAlias 右边字段表别名
   * @param rightField 右边字段枚举
   * @return 具体实现
   */
  C lt(Enum<?> leftField, String rightTableAlias, Enum<?> rightField);

  /**
   * 小于条件
   *
   * @param leftField 左边字段名称
   * @param rightField 右边字段枚举
   * @return 具体实现
   */
  C lt(String leftField, Enum<?> rightField);

  /**
   * 小于条件
   *
   * @param leftField 左边字段名称
   * @param rightTableAlias 右边字段表别名
   * @param rightField 右边字段枚举
   * @return 具体实现
   */
  C lt(String leftField, String rightTableAlias, Enum<?> rightField);

  /**
   * 小于条件
   *
   * @param leftField 左边字段枚举
   * @param rightField 右边字段名称
   * @return 具体实现
   */
  C lt(Enum<?> leftField, String rightField);

  /**
   * 小于条件
   *
   * @param leftTableAlias 左边字段表别名
   * @param leftField 左边字段枚举
   * @param rightField 右边字段名称
   * @return 具体实现
   */
  C lt(String leftTableAlias, Enum<?> leftField, String rightField);

  /**
   * 小于条件
   *
   * @param leftField 左边字段名称
   * @param sqlBuilderConsumer SQL构建器消费器
   * @return 具体实现
   */
  C lt(String leftField, Consumer<StandardSelectSql> sqlBuilderConsumer);

  /**
   * 小于条件
   *
   * @param leftField 左边字段枚举
   * @param sqlBuilderConsumer SQL构建器消费器
   * @return 具体实现
   */
  C lt(Enum<?> leftField, Consumer<StandardSelectSql> sqlBuilderConsumer);

  /**
   * 小于条件
   *
   * @param leftTableAlias 左边字段表别名
   * @param leftField 左边字段枚举
   * @param sqlBuilderConsumer SQL构建器消费器
   * @return 具体实现
   */
  C lt(String leftTableAlias, Enum<?> leftField, Consumer<StandardSelectSql> sqlBuilderConsumer);

  /**
   * 小于条件
   *
   * @param condition 条件
   * @param leftField 左边字段名称
   * @param rightField 右边字段名称
   * @return 具体实现
   */
  default C lt(boolean condition, String leftField, String rightField) {
    if (condition) {
      return this.lt(leftField, rightField);
    }

    return (C) this;
  }

  /**
   * 小于条件
   *
   * @param condition 条件
   * @param leftField 左边字段枚举
   * @param rightField 右边字段枚举
   * @return 具体实现
   */
  default C lt(boolean condition, Enum<?> leftField, Enum<?> rightField) {
    if (condition) {
      return this.lt(leftField, rightField);
    }

    return (C) this;
  }

  /**
   * 小于条件
   *
   * @param condition 条件
   * @param leftTableAlias 左边字段表别名
   * @param leftField 左边字段枚举
   * @param rightTableAlias 右边字段表别名
   * @param rightField 右边字段枚举
   * @return 具体实现
   */
  default C lt(
      boolean condition,
      String leftTableAlias,
      Enum<?> leftField,
      String rightTableAlias,
      Enum<?> rightField) {
    if (condition) {
      return this.lt(leftTableAlias, leftField, rightTableAlias, rightField);
    }

    return (C) this;
  }

  /**
   * 小于条件
   *
   * @param condition 条件
   * @param leftTableAlias 左边字段表别名
   * @param leftField 左边字段枚举
   * @param rightField 右边字段枚举
   * @return 具体实现
   */
  default C lt(boolean condition, String leftTableAlias, Enum<?> leftField, Enum<?> rightField) {
    if (condition) {
      return this.lt(leftTableAlias, leftField, rightField);
    }

    return (C) this;
  }

  /**
   * 小于条件
   *
   * @param condition 条件
   * @param leftField 左边字段枚举
   * @param rightTableAlias 右边字段表别名
   * @param rightField 右边字段枚举
   * @return 具体实现
   */
  default C lt(boolean condition, Enum<?> leftField, String rightTableAlias, Enum<?> rightField) {
    if (condition) {
      return this.lt(leftField, rightTableAlias, rightField);
    }

    return (C) this;
  }

  /**
   * 小于条件
   *
   * @param condition 条件
   * @param leftField 左边字段名称
   * @param rightField 右边字段枚举
   * @return 具体实现
   */
  default C lt(boolean condition, String leftField, Enum<?> rightField) {
    if (condition) {
      return this.lt(leftField, rightField);
    }

    return (C) this;
  }

  /**
   * 小于条件
   *
   * @param condition 条件
   * @param leftField 左边字段名称
   * @param rightTableAlias 右边字段表别名
   * @param rightField 右边字段枚举
   * @return 具体实现
   */
  default C lt(boolean condition, String leftField, String rightTableAlias, Enum<?> rightField) {
    if (condition) {
      return this.lt(leftField, rightTableAlias, rightField);
    }

    return (C) this;
  }

  /**
   * 小于条件
   *
   * @param condition 条件
   * @param leftField 左边字段枚举
   * @param rightField 右边字段名称
   * @return 具体实现
   */
  default C lt(boolean condition, Enum<?> leftField, String rightField) {
    if (condition) {
      return this.lt(leftField, rightField);
    }

    return (C) this;
  }

  /**
   * 小于条件
   *
   * @param condition 条件
   * @param leftTableAlias 左边字段表别名
   * @param leftField 左边字段枚举
   * @param rightField 右边字段名称
   * @return 具体实现
   */
  default C lt(boolean condition, String leftTableAlias, Enum<?> leftField, String rightField) {
    if (condition) {
      return this.lt(leftTableAlias, leftField, rightField);
    }

    return (C) this;
  }

  /**
   * 小于条件
   *
   * @param condition 条件
   * @param leftField 左边字段名称
   * @param sqlBuilderConsumer SQL构建器消费器
   * @return 具体实现
   */
  default C lt(
      boolean condition, String leftField, Consumer<StandardSelectSql> sqlBuilderConsumer) {
    if (condition) {
      return this.lt(leftField, sqlBuilderConsumer);
    }

    return (C) this;
  }

  /**
   * 小于条件
   *
   * @param condition 条件
   * @param leftField 左边字段枚举
   * @param sqlBuilderConsumer SQL构建器消费器
   * @return 具体实现
   */
  default C lt(
      boolean condition, Enum<?> leftField, Consumer<StandardSelectSql> sqlBuilderConsumer) {
    if (condition) {
      return this.lt(leftField, sqlBuilderConsumer);
    }

    return (C) this;
  }

  /**
   * 小于条件
   *
   * @param condition 条件
   * @param leftTableAlias 左边字段表别名
   * @param leftField 左边字段枚举
   * @param sqlBuilderConsumer SQL构建器消费器
   * @return 具体实现
   */
  default C lt(
      boolean condition,
      String leftTableAlias,
      Enum<?> leftField,
      Consumer<StandardSelectSql> sqlBuilderConsumer) {
    if (condition) {
      return this.lt(leftTableAlias, leftField, sqlBuilderConsumer);
    }

    return (C) this;
  }

  /**
   * 小于条件
   *
   * @param leftField 左边字段名称
   * @param rightValue 右边值
   * @return 具体实现
   */
  C ltValue(String leftField, Object rightValue);

  /**
   * 小于条件
   *
   * @param leftField 左边字段枚举
   * @param rightValue 右边值
   * @return 具体实现
   */
  C ltValue(Enum<?> leftField, Object rightValue);

  /**
   * 小于条件
   *
   * @param leftTableAlias 左边字段表别名
   * @param leftField 左边字段枚举
   * @param rightValue 右边值
   * @return 具体实现
   */
  C ltValue(String leftTableAlias, Enum<?> leftField, Object rightValue);

  /**
   * 小于条件
   *
   * @param condition 条件
   * @param leftField 左边字段名称
   * @param rightValue 右边值
   * @return 具体实现
   */
  default C ltValue(boolean condition, String leftField, Object rightValue) {
    if (condition) {
      return this.ltValue(leftField, rightValue);
    }

    return (C) this;
  }

  /**
   * 小于条件
   *
   * @param condition 条件
   * @param leftField 左边字段枚举
   * @param rightValue 右边值
   * @return 具体实现
   */
  default C ltValue(boolean condition, Enum<?> leftField, Object rightValue) {
    if (condition) {
      return this.ltValue(leftField, rightValue);
    }

    return (C) this;
  }

  /**
   * 小于条件
   *
   * @param condition 条件
   * @param leftTableAlias 左边字段表别名
   * @param leftField 左边字段枚举
   * @param rightValue 右边值
   * @return 具体实现
   */
  default C ltValue(
      boolean condition, String leftTableAlias, Enum<?> leftField, Object rightValue) {
    if (condition) {
      return this.ltValue(leftTableAlias, leftField, rightValue);
    }

    return (C) this;
  }

  /**
   * 小于等于条件
   *
   * @param leftField 左边字段名称
   * @param rightField 右边字段名称
   * @return 具体实现
   */
  C le(String leftField, String rightField);

  /**
   * 小于等于条件
   *
   * @param leftField 左边字段枚举
   * @param rightField 右边字段枚举
   * @return 具体实现
   */
  C le(Enum<?> leftField, Enum<?> rightField);

  /**
   * 小于等于条件
   *
   * @param leftTableAlias 左边字段表别名
   * @param leftField 左边字段枚举
   * @param rightTableAlias 右边字段表别名
   * @param rightField 右边字段枚举
   * @return 具体实现
   */
  C le(String leftTableAlias, Enum<?> leftField, String rightTableAlias, Enum<?> rightField);

  /**
   * 小于等于条件
   *
   * @param leftTableAlias 左边字段表别名
   * @param leftField 左边字段枚举
   * @param rightField 右边字段枚举
   * @return 具体实现
   */
  C le(String leftTableAlias, Enum<?> leftField, Enum<?> rightField);

  /**
   * 小于等于条件
   *
   * @param leftField 左边字段枚举
   * @param rightTableAlias 右边字段表别名
   * @param rightField 右边字段枚举
   * @return 具体实现
   */
  C le(Enum<?> leftField, String rightTableAlias, Enum<?> rightField);

  /**
   * 小于等于条件
   *
   * @param leftField 左边字段名称
   * @param rightField 右边字段枚举
   * @return 具体实现
   */
  C le(String leftField, Enum<?> rightField);

  /**
   * 小于等于条件
   *
   * @param leftField 左边字段名称
   * @param rightTableAlias 右边字段表别名
   * @param rightField 右边字段枚举
   * @return 具体实现
   */
  C le(String leftField, String rightTableAlias, Enum<?> rightField);

  /**
   * 小于等于条件
   *
   * @param leftField 左边字段枚举
   * @param rightField 右边字段名称
   * @return 具体实现
   */
  C le(Enum<?> leftField, String rightField);

  /**
   * 小于等于条件
   *
   * @param leftTableAlias 左边字段表别名
   * @param leftField 左边字段枚举
   * @param rightField 右边字段名称
   * @return 具体实现
   */
  C le(String leftTableAlias, Enum<?> leftField, String rightField);

  /**
   * 小于等于条件
   *
   * @param leftField 左边字段名称
   * @param sqlBuilderConsumer SQL构建器消费器
   * @return 具体实现
   */
  C le(String leftField, Consumer<StandardSelectSql> sqlBuilderConsumer);

  /**
   * 小于等于条件
   *
   * @param leftField 左边字段枚举
   * @param sqlBuilderConsumer SQL构建器消费器
   * @return 具体实现
   */
  C le(Enum<?> leftField, Consumer<StandardSelectSql> sqlBuilderConsumer);

  /**
   * 小于等于条件
   *
   * @param leftTableAlias 左边字段表别名
   * @param leftField 左边字段枚举
   * @param sqlBuilderConsumer SQL构建器消费器
   * @return 具体实现
   */
  C le(String leftTableAlias, Enum<?> leftField, Consumer<StandardSelectSql> sqlBuilderConsumer);

  /**
   * 小于等于条件
   *
   * @param condition 条件
   * @param leftField 左边字段名称
   * @param rightField 右边字段名称
   * @return 具体实现
   */
  default C le(boolean condition, String leftField, String rightField) {
    if (condition) {
      return this.le(leftField, rightField);
    }

    return (C) this;
  }

  /**
   * 小于等于条件
   *
   * @param condition 条件
   * @param leftField 左边字段枚举
   * @param rightField 右边字段枚举
   * @return 具体实现
   */
  default C le(boolean condition, Enum<?> leftField, Enum<?> rightField) {
    if (condition) {
      return this.le(leftField, rightField);
    }

    return (C) this;
  }

  /**
   * 小于等于条件
   *
   * @param condition 条件
   * @param leftTableAlias 左边字段表别名
   * @param leftField 左边字段枚举
   * @param rightTableAlias 右边字段表别名
   * @param rightField 右边字段枚举
   * @return 具体实现
   */
  default C le(
      boolean condition,
      String leftTableAlias,
      Enum<?> leftField,
      String rightTableAlias,
      Enum<?> rightField) {
    if (condition) {
      return this.le(leftTableAlias, leftField, rightTableAlias, rightField);
    }

    return (C) this;
  }

  /**
   * 小于等于条件
   *
   * @param condition 条件
   * @param leftTableAlias 左边字段表别名
   * @param leftField 左边字段枚举
   * @param rightField 右边字段枚举
   * @return 具体实现
   */
  default C le(boolean condition, String leftTableAlias, Enum<?> leftField, Enum<?> rightField) {
    if (condition) {
      return this.le(leftTableAlias, leftField, rightField);
    }

    return (C) this;
  }

  /**
   * 小于等于条件
   *
   * @param condition 条件
   * @param leftField 左边字段枚举
   * @param rightTableAlias 右边字段表别名
   * @param rightField 右边字段枚举
   * @return 具体实现
   */
  default C le(boolean condition, Enum<?> leftField, String rightTableAlias, Enum<?> rightField) {
    if (condition) {
      return this.le(leftField, rightTableAlias, rightField);
    }

    return (C) this;
  }

  /**
   * 小于等于条件
   *
   * @param condition 条件
   * @param leftField 左边字段名称
   * @param rightField 右边字段枚举
   * @return 具体实现
   */
  default C le(boolean condition, String leftField, Enum<?> rightField) {
    if (condition) {
      return this.le(leftField, rightField);
    }

    return (C) this;
  }

  /**
   * 小于等于条件
   *
   * @param condition 条件
   * @param leftField 左边字段名称
   * @param rightTableAlias 右边字段表别名
   * @param rightField 右边字段枚举
   * @return 具体实现
   */
  default C le(boolean condition, String leftField, String rightTableAlias, Enum<?> rightField) {
    if (condition) {
      return this.le(leftField, rightTableAlias, rightField);
    }

    return (C) this;
  }

  /**
   * 小于等于条件
   *
   * @param condition 条件
   * @param leftField 左边字段枚举
   * @param rightField 右边字段名称
   * @return 具体实现
   */
  default C le(boolean condition, Enum<?> leftField, String rightField) {
    if (condition) {
      return this.le(leftField, rightField);
    }

    return (C) this;
  }

  /**
   * 小于等于条件
   *
   * @param condition 条件
   * @param leftTableAlias 左边字段表别名
   * @param leftField 左边字段枚举
   * @param rightField 右边字段名称
   * @return 具体实现
   */
  default C le(boolean condition, String leftTableAlias, Enum<?> leftField, String rightField) {
    if (condition) {
      return this.le(leftTableAlias, leftField, rightField);
    }

    return (C) this;
  }

  /**
   * 小于等于条件
   *
   * @param condition 条件
   * @param leftField 左边字段名称
   * @param sqlBuilderConsumer SQL构建器消费器
   * @return 具体实现
   */
  default C le(
      boolean condition, String leftField, Consumer<StandardSelectSql> sqlBuilderConsumer) {
    if (condition) {
      return this.le(leftField, sqlBuilderConsumer);
    }

    return (C) this;
  }

  /**
   * 小于等于条件
   *
   * @param condition 条件
   * @param leftField 左边字段枚举
   * @param sqlBuilderConsumer SQL构建器消费器
   * @return 具体实现
   */
  default C le(
      boolean condition, Enum<?> leftField, Consumer<StandardSelectSql> sqlBuilderConsumer) {
    if (condition) {
      return this.le(leftField, sqlBuilderConsumer);
    }

    return (C) this;
  }

  /**
   * 小于等于条件
   *
   * @param condition 条件
   * @param leftTableAlias 左边字段表别名
   * @param leftField 左边字段枚举
   * @param sqlBuilderConsumer SQL构建器消费器
   * @return 具体实现
   */
  default C le(
      boolean condition,
      String leftTableAlias,
      Enum<?> leftField,
      Consumer<StandardSelectSql> sqlBuilderConsumer) {
    if (condition) {
      return this.le(leftTableAlias, leftField, sqlBuilderConsumer);
    }

    return (C) this;
  }

  /**
   * 小于等于条件
   *
   * @param leftField 左边字段名称
   * @param rightValue 右边值
   * @return 具体实现
   */
  C leValue(String leftField, Object rightValue);

  /**
   * 小于等于条件
   *
   * @param leftField 左边字段枚举
   * @param rightValue 右边值
   * @return 具体实现
   */
  C leValue(Enum<?> leftField, Object rightValue);

  /**
   * 小于等于条件
   *
   * @param leftTableAlias 左边字段表别名
   * @param leftField 左边字段枚举
   * @param rightValue 右边值
   * @return 具体实现
   */
  C leValue(String leftTableAlias, Enum<?> leftField, Object rightValue);

  /**
   * 小于等于条件
   *
   * @param condition 条件
   * @param leftField 左边字段名称
   * @param rightValue 右边值
   * @return 具体实现
   */
  default C leValue(boolean condition, String leftField, Object rightValue) {
    if (condition) {
      return this.leValue(leftField, rightValue);
    }

    return (C) this;
  }

  /**
   * 小于等于条件
   *
   * @param condition 条件
   * @param leftField 左边字段枚举
   * @param rightValue 右边值
   * @return 具体实现
   */
  default C leValue(boolean condition, Enum<?> leftField, Object rightValue) {
    if (condition) {
      return this.leValue(leftField, rightValue);
    }

    return (C) this;
  }

  /**
   * 小于等于条件
   *
   * @param condition 条件
   * @param leftTableAlias 左边字段表别名
   * @param leftField 左边字段枚举
   * @param rightValue 右边值
   * @return 具体实现
   */
  default C leValue(
      boolean condition, String leftTableAlias, Enum<?> leftField, Object rightValue) {
    if (condition) {
      return this.leValue(leftTableAlias, leftField, rightValue);
    }

    return (C) this;
  }

  /**
   * 大于条件
   *
   * @param leftField 左边字段名称
   * @param rightField 右边字段名称
   * @return 具体实现
   */
  C gt(String leftField, String rightField);

  /**
   * 大于条件
   *
   * @param leftField 左边字段枚举
   * @param rightField 右边字段枚举
   * @return 具体实现
   */
  C gt(Enum<?> leftField, Enum<?> rightField);

  /**
   * 大于条件
   *
   * @param leftTableAlias 左边字段表别名
   * @param leftField 左边字段枚举
   * @param rightTableAlias 右边字段表别名
   * @param rightField 右边字段枚举
   * @return 具体实现
   */
  C gt(String leftTableAlias, Enum<?> leftField, String rightTableAlias, Enum<?> rightField);

  /**
   * 大于条件
   *
   * @param leftTableAlias 左边字段表别名
   * @param leftField 左边字段枚举
   * @param rightField 右边字段枚举
   * @return 具体实现
   */
  C gt(String leftTableAlias, Enum<?> leftField, Enum<?> rightField);

  /**
   * 大于条件
   *
   * @param leftField 左边字段枚举
   * @param rightTableAlias 右边字段表别名
   * @param rightField 右边字段枚举
   * @return 具体实现
   */
  C gt(Enum<?> leftField, String rightTableAlias, Enum<?> rightField);

  /**
   * 大于条件
   *
   * @param leftField 左边字段名称
   * @param rightField 右边字段枚举
   * @return 具体实现
   */
  C gt(String leftField, Enum<?> rightField);

  /**
   * 大于条件
   *
   * @param leftField 左边字段名称
   * @param rightTableAlias 右边字段表别名
   * @param rightField 右边字段枚举
   * @return 具体实现
   */
  C gt(String leftField, String rightTableAlias, Enum<?> rightField);

  /**
   * 大于条件
   *
   * @param leftField 左边字段枚举
   * @param rightField 右边字段名称
   * @return 具体实现
   */
  C gt(Enum<?> leftField, String rightField);

  /**
   * 大于条件
   *
   * @param leftTableAlias 左边字段表别名
   * @param leftField 左边字段枚举
   * @param rightField 右边字段名称
   * @return 具体实现
   */
  C gt(String leftTableAlias, Enum<?> leftField, String rightField);

  /**
   * 大于条件
   *
   * @param leftField 左边字段名称
   * @param sqlBuilderConsumer SQL构建器消费器
   * @return 具体实现
   */
  C gt(String leftField, Consumer<StandardSelectSql> sqlBuilderConsumer);

  /**
   * 大于条件
   *
   * @param leftField 左边字段枚举
   * @param sqlBuilderConsumer SQL构建器消费器
   * @return 具体实现
   */
  C gt(Enum<?> leftField, Consumer<StandardSelectSql> sqlBuilderConsumer);

  /**
   * 大于条件
   *
   * @param leftTableAlias 左边字段表别名
   * @param leftField 左边字段枚举
   * @param sqlBuilderConsumer SQL构建器消费器
   * @return 具体实现
   */
  C gt(String leftTableAlias, Enum<?> leftField, Consumer<StandardSelectSql> sqlBuilderConsumer);

  /**
   * 大于条件
   *
   * @param condition 条件
   * @param leftField 左边字段名称
   * @param rightField 右边字段名称
   * @return 具体实现
   */
  default C gt(boolean condition, String leftField, String rightField) {
    if (condition) {
      return this.gt(leftField, rightField);
    }

    return (C) this;
  }

  /**
   * 大于条件
   *
   * @param condition 条件
   * @param leftField 左边字段枚举
   * @param rightField 右边字段枚举
   * @return 具体实现
   */
  default C gt(boolean condition, Enum<?> leftField, Enum<?> rightField) {
    if (condition) {
      return this.gt(leftField, rightField);
    }

    return (C) this;
  }

  /**
   * 大于条件
   *
   * @param condition 条件
   * @param leftTableAlias 左边字段表别名
   * @param leftField 左边字段枚举
   * @param rightTableAlias 右边字段表别名
   * @param rightField 右边字段枚举
   * @return 具体实现
   */
  default C gt(
      boolean condition,
      String leftTableAlias,
      Enum<?> leftField,
      String rightTableAlias,
      Enum<?> rightField) {
    if (condition) {
      return this.gt(leftTableAlias, leftField, rightTableAlias, rightField);
    }

    return (C) this;
  }

  /**
   * 大于条件
   *
   * @param condition 条件
   * @param leftTableAlias 左边字段表别名
   * @param leftField 左边字段枚举
   * @param rightField 右边字段枚举
   * @return 具体实现
   */
  default C gt(boolean condition, String leftTableAlias, Enum<?> leftField, Enum<?> rightField) {
    if (condition) {
      return this.gt(leftTableAlias, leftField, rightField);
    }

    return (C) this;
  }

  /**
   * 大于条件
   *
   * @param condition 条件
   * @param leftField 左边字段枚举
   * @param rightTableAlias 右边字段表别名
   * @param rightField 右边字段枚举
   * @return 具体实现
   */
  default C gt(boolean condition, Enum<?> leftField, String rightTableAlias, Enum<?> rightField) {
    if (condition) {
      return this.gt(leftField, rightTableAlias, rightField);
    }

    return (C) this;
  }

  /**
   * 大于条件
   *
   * @param condition 条件
   * @param leftField 左边字段名称
   * @param rightField 右边字段枚举
   * @return 具体实现
   */
  default C gt(boolean condition, String leftField, Enum<?> rightField) {
    if (condition) {
      return this.gt(leftField, rightField);
    }

    return (C) this;
  }

  /**
   * 大于条件
   *
   * @param condition 条件
   * @param leftField 左边字段名称
   * @param rightTableAlias 右边字段表别名
   * @param rightField 右边字段枚举
   * @return 具体实现
   */
  default C gt(boolean condition, String leftField, String rightTableAlias, Enum<?> rightField) {
    if (condition) {
      return this.gt(leftField, rightTableAlias, rightField);
    }

    return (C) this;
  }

  /**
   * 大于条件
   *
   * @param condition 条件
   * @param leftField 左边字段枚举
   * @param rightField 右边字段名称
   * @return 具体实现
   */
  default C gt(boolean condition, Enum<?> leftField, String rightField) {
    if (condition) {
      return this.gt(leftField, rightField);
    }

    return (C) this;
  }

  /**
   * 大于条件
   *
   * @param condition 条件
   * @param leftTableAlias 左边字段表别名
   * @param leftField 左边字段枚举
   * @param rightField 右边字段名称
   * @return 具体实现
   */
  default C gt(boolean condition, String leftTableAlias, Enum<?> leftField, String rightField) {
    if (condition) {
      return this.gt(leftTableAlias, leftField, rightField);
    }

    return (C) this;
  }

  /**
   * 大于条件
   *
   * @param condition 条件
   * @param leftField 左边字段名称
   * @param sqlBuilderConsumer SQL构建器消费器
   * @return 具体实现
   */
  default C gt(
      boolean condition, String leftField, Consumer<StandardSelectSql> sqlBuilderConsumer) {
    if (condition) {
      return this.gt(leftField, sqlBuilderConsumer);
    }

    return (C) this;
  }

  /**
   * 大于条件
   *
   * @param condition 条件
   * @param leftField 左边字段枚举
   * @param sqlBuilderConsumer SQL构建器消费器
   * @return 具体实现
   */
  default C gt(
      boolean condition, Enum<?> leftField, Consumer<StandardSelectSql> sqlBuilderConsumer) {
    if (condition) {
      return this.gt(leftField, sqlBuilderConsumer);
    }

    return (C) this;
  }

  /**
   * 大于条件
   *
   * @param condition 条件
   * @param leftTableAlias 左边字段表别名
   * @param leftField 左边字段枚举
   * @param sqlBuilderConsumer SQL构建器消费器
   * @return 具体实现
   */
  default C gt(
      boolean condition,
      String leftTableAlias,
      Enum<?> leftField,
      Consumer<StandardSelectSql> sqlBuilderConsumer) {
    if (condition) {
      return this.gt(leftTableAlias, leftField, sqlBuilderConsumer);
    }

    return (C) this;
  }

  /**
   * 大于条件
   *
   * @param leftField 左边字段名称
   * @param rightValue 右边值
   * @return 具体实现
   */
  C gtValue(String leftField, Object rightValue);

  /**
   * 大于条件
   *
   * @param leftField 左边字段枚举
   * @param rightValue 右边值
   * @return 具体实现
   */
  C gtValue(Enum<?> leftField, Object rightValue);

  /**
   * 大于条件
   *
   * @param leftTableAlias 左边字段表别名
   * @param leftField 左边字段枚举
   * @param rightValue 右边值
   * @return 具体实现
   */
  C gtValue(String leftTableAlias, Enum<?> leftField, Object rightValue);

  /**
   * 大于条件
   *
   * @param condition 条件
   * @param leftField 左边字段名称
   * @param rightValue 右边值
   * @return 具体实现
   */
  default C gtValue(boolean condition, String leftField, Object rightValue) {
    if (condition) {
      return this.gtValue(leftField, rightValue);
    }

    return (C) this;
  }

  /**
   * 大于条件
   *
   * @param condition 条件
   * @param leftField 左边字段枚举
   * @param rightValue 右边值
   * @return 具体实现
   */
  default C gtValue(boolean condition, Enum<?> leftField, Object rightValue) {
    if (condition) {
      return this.gtValue(leftField, rightValue);
    }

    return (C) this;
  }

  /**
   * 大于条件
   *
   * @param condition 条件
   * @param leftTableAlias 左边字段表别名
   * @param leftField 左边字段枚举
   * @param rightValue 右边值
   * @return 具体实现
   */
  default C gtValue(
      boolean condition, String leftTableAlias, Enum<?> leftField, Object rightValue) {
    if (condition) {
      return this.gtValue(leftTableAlias, leftField, rightValue);
    }

    return (C) this;
  }

  /**
   * 大于等于条件
   *
   * @param leftField 左边字段名称
   * @param rightField 右边字段名称
   * @return 具体实现
   */
  C ge(String leftField, String rightField);

  /**
   * 大于等于条件
   *
   * @param leftField 左边字段枚举
   * @param rightField 右边字段枚举
   * @return 具体实现
   */
  C ge(Enum<?> leftField, Enum<?> rightField);

  /**
   * 大于等于条件
   *
   * @param leftTableAlias 左边字段表别名
   * @param leftField 左边字段枚举
   * @param rightTableAlias 右边字段表别名
   * @param rightField 右边字段枚举
   * @return 具体实现
   */
  C ge(String leftTableAlias, Enum<?> leftField, String rightTableAlias, Enum<?> rightField);

  /**
   * 大于等于条件
   *
   * @param leftTableAlias 左边字段表别名
   * @param leftField 左边字段枚举
   * @param rightField 右边字段枚举
   * @return 具体实现
   */
  C ge(String leftTableAlias, Enum<?> leftField, Enum<?> rightField);

  /**
   * 大于等于条件
   *
   * @param leftField 左边字段枚举
   * @param rightTableAlias 右边字段表别名
   * @param rightField 右边字段枚举
   * @return 具体实现
   */
  C ge(Enum<?> leftField, String rightTableAlias, Enum<?> rightField);

  /**
   * 大于等于条件
   *
   * @param leftField 左边字段名称
   * @param rightField 右边字段枚举
   * @return 具体实现
   */
  C ge(String leftField, Enum<?> rightField);

  /**
   * 大于等于条件
   *
   * @param leftField 左边字段名称
   * @param rightTableAlias 右边字段表别名
   * @param rightField 右边字段枚举
   * @return 具体实现
   */
  C ge(String leftField, String rightTableAlias, Enum<?> rightField);

  /**
   * 大于等于条件
   *
   * @param leftField 左边字段枚举
   * @param rightField 右边字段名称
   * @return 具体实现
   */
  C ge(Enum<?> leftField, String rightField);

  /**
   * 大于等于条件
   *
   * @param leftTableAlias 左边字段表别名
   * @param leftField 左边字段枚举
   * @param rightField 右边字段名称
   * @return 具体实现
   */
  C ge(String leftTableAlias, Enum<?> leftField, String rightField);

  /**
   * 大于等于条件
   *
   * @param leftField 左边字段名称
   * @param sqlBuilderConsumer SQL构建器消费器
   * @return 具体实现
   */
  C ge(String leftField, Consumer<StandardSelectSql> sqlBuilderConsumer);

  /**
   * 大于等于条件
   *
   * @param leftField 左边字段枚举
   * @param sqlBuilderConsumer SQL构建器消费器
   * @return 具体实现
   */
  C ge(Enum<?> leftField, Consumer<StandardSelectSql> sqlBuilderConsumer);

  /**
   * 大于等于条件
   *
   * @param leftTableAlias 左边字段表别名
   * @param leftField 左边字段枚举
   * @param sqlBuilderConsumer SQL构建器消费器
   * @return 具体实现
   */
  C ge(String leftTableAlias, Enum<?> leftField, Consumer<StandardSelectSql> sqlBuilderConsumer);

  /**
   * 大于等于条件
   *
   * @param condition 条件
   * @param leftField 左边字段名称
   * @param rightField 右边字段名称
   * @return 具体实现
   */
  default C ge(boolean condition, String leftField, String rightField) {
    if (condition) {
      return this.ge(leftField, rightField);
    }

    return (C) this;
  }

  /**
   * 大于等于条件
   *
   * @param condition 条件
   * @param leftField 左边字段枚举
   * @param rightField 右边字段枚举
   * @return 具体实现
   */
  default C ge(boolean condition, Enum<?> leftField, Enum<?> rightField) {
    if (condition) {
      return this.ge(leftField, rightField);
    }

    return (C) this;
  }

  /**
   * 大于等于条件
   *
   * @param condition 条件
   * @param leftTableAlias 左边字段表别名
   * @param leftField 左边字段枚举
   * @param rightTableAlias 右边字段表别名
   * @param rightField 右边字段枚举
   * @return 具体实现
   */
  default C ge(
      boolean condition,
      String leftTableAlias,
      Enum<?> leftField,
      String rightTableAlias,
      Enum<?> rightField) {
    if (condition) {
      return this.ge(leftTableAlias, leftField, rightTableAlias, rightField);
    }

    return (C) this;
  }

  /**
   * 大于等于条件
   *
   * @param condition 条件
   * @param leftTableAlias 左边字段表别名
   * @param leftField 左边字段枚举
   * @param rightField 右边字段枚举
   * @return 具体实现
   */
  default C ge(boolean condition, String leftTableAlias, Enum<?> leftField, Enum<?> rightField) {
    if (condition) {
      return this.ge(leftTableAlias, leftField, rightField);
    }

    return (C) this;
  }

  /**
   * 大于等于条件
   *
   * @param condition 条件
   * @param leftField 左边字段枚举
   * @param rightTableAlias 右边字段表别名
   * @param rightField 右边字段枚举
   * @return 具体实现
   */
  default C ge(boolean condition, Enum<?> leftField, String rightTableAlias, Enum<?> rightField) {
    if (condition) {
      return this.ge(leftField, rightTableAlias, rightField);
    }

    return (C) this;
  }

  /**
   * 大于等于条件
   *
   * @param condition 条件
   * @param leftField 左边字段名称
   * @param rightField 右边字段枚举
   * @return 具体实现
   */
  default C ge(boolean condition, String leftField, Enum<?> rightField) {
    if (condition) {
      return this.ge(leftField, rightField);
    }

    return (C) this;
  }

  /**
   * 大于等于条件
   *
   * @param condition 条件
   * @param leftField 左边字段名称
   * @param rightTableAlias 右边字段表别名
   * @param rightField 右边字段枚举
   * @return 具体实现
   */
  default C ge(boolean condition, String leftField, String rightTableAlias, Enum<?> rightField) {
    if (condition) {
      return this.ge(leftField, rightTableAlias, rightField);
    }

    return (C) this;
  }

  /**
   * 大于等于条件
   *
   * @param condition 条件
   * @param leftField 左边字段枚举
   * @param rightField 右边字段名称
   * @return 具体实现
   */
  default C ge(boolean condition, Enum<?> leftField, String rightField) {
    if (condition) {
      return this.ge(leftField, rightField);
    }

    return (C) this;
  }

  /**
   * 大于等于条件
   *
   * @param condition 条件
   * @param leftTableAlias 左边字段表别名
   * @param leftField 左边字段枚举
   * @param rightField 右边字段名称
   * @return 具体实现
   */
  default C ge(boolean condition, String leftTableAlias, Enum<?> leftField, String rightField) {
    if (condition) {
      return this.ge(leftTableAlias, leftField, rightField);
    }

    return (C) this;
  }

  /**
   * 大于等于条件
   *
   * @param condition 条件
   * @param leftField 左边字段名称
   * @param sqlBuilderConsumer SQL构建器消费器
   * @return 具体实现
   */
  default C ge(
      boolean condition, String leftField, Consumer<StandardSelectSql> sqlBuilderConsumer) {
    if (condition) {
      return this.ge(leftField, sqlBuilderConsumer);
    }

    return (C) this;
  }

  /**
   * 大于等于条件
   *
   * @param condition 条件
   * @param leftField 左边字段枚举
   * @param sqlBuilderConsumer SQL构建器消费器
   * @return 具体实现
   */
  default C ge(
      boolean condition, Enum<?> leftField, Consumer<StandardSelectSql> sqlBuilderConsumer) {
    if (condition) {
      return this.ge(leftField, sqlBuilderConsumer);
    }

    return (C) this;
  }

  /**
   * 大于等于条件
   *
   * @param condition 条件
   * @param leftTableAlias 左边字段表别名
   * @param leftField 左边字段枚举
   * @param sqlBuilderConsumer SQL构建器消费器
   * @return 具体实现
   */
  default C ge(
      boolean condition,
      String leftTableAlias,
      Enum<?> leftField,
      Consumer<StandardSelectSql> sqlBuilderConsumer) {
    if (condition) {
      return this.ge(leftTableAlias, leftField, sqlBuilderConsumer);
    }

    return (C) this;
  }

  /**
   * 大于等于条件
   *
   * @param leftField 左边字段名称
   * @param rightValue 右边值
   * @return 具体实现
   */
  C geValue(String leftField, Object rightValue);

  /**
   * 大于等于条件
   *
   * @param leftField 左边字段枚举
   * @param rightValue 右边值
   * @return 具体实现
   */
  C geValue(Enum<?> leftField, Object rightValue);

  /**
   * 大于等于条件
   *
   * @param leftTableAlias 左边字段表别名
   * @param leftField 左边字段枚举
   * @param rightValue 右边值
   * @return 具体实现
   */
  C geValue(String leftTableAlias, Enum<?> leftField, Object rightValue);

  /**
   * 大于等于条件
   *
   * @param condition 条件
   * @param leftField 左边字段名称
   * @param rightValue 右边值
   * @return 具体实现
   */
  default C geValue(boolean condition, String leftField, Object rightValue) {
    if (condition) {
      return this.geValue(leftField, rightValue);
    }

    return (C) this;
  }

  /**
   * 大于等于条件
   *
   * @param condition 条件
   * @param leftField 左边字段枚举
   * @param rightValue 右边值
   * @return 具体实现
   */
  default C geValue(boolean condition, Enum<?> leftField, Object rightValue) {
    if (condition) {
      return this.geValue(leftField, rightValue);
    }

    return (C) this;
  }

  /**
   * 大于等于条件
   *
   * @param condition 条件
   * @param leftTableAlias 左边字段表别名
   * @param leftField 左边字段枚举
   * @param rightValue 右边值
   * @return 具体实现
   */
  default C geValue(
      boolean condition, String leftTableAlias, Enum<?> leftField, Object rightValue) {
    if (condition) {
      return this.geValue(leftTableAlias, leftField, rightValue);
    }

    return (C) this;
  }

  /**
   * 区间条件
   *
   * @param leftField 左边字段名称
   * @param beginField 区间开始字段名称
   * @param endField 区间结束字段名称
   * @return 具体实现
   */
  C between(String leftField, String beginField, String endField);

  /**
   * 区间条件
   *
   * @param leftField 左边字段名称
   * @param beginField 区间开始字段枚举
   * @param endField 区间结束字段枚举
   * @return 具体实现
   */
  C between(String leftField, Enum<?> beginField, Enum<?> endField);

  /**
   * 区间条件
   *
   * @param leftField 左边字段名称
   * @param beginField 区间开始字段名称
   * @param endField 区间结束字段枚举
   * @return 具体实现
   */
  C between(String leftField, String beginField, Enum<?> endField);

  /**
   * 区间条件
   *
   * @param leftField 左边字段名称
   * @param beginField 区间开始字段枚举
   * @param endField 区间结束字段名称
   * @return 具体实现
   */
  C between(String leftField, Enum<?> beginField, String endField);

  /**
   * 区间条件
   *
   * @param leftField 左边字段枚举
   * @param beginField 区间开始字段枚举
   * @param endField 区间结束字段枚举
   * @return 具体实现
   */
  C between(Enum<?> leftField, Enum<?> beginField, Enum<?> endField);

  /**
   * 区间条件
   *
   * @param leftField 左边字段枚举
   * @param beginField 区间开始字段
   * @param endField 区间结束字段枚举
   * @return 具体实现
   */
  C between(Enum<?> leftField, String beginField, Enum<?> endField);

  /**
   * 区间条件
   *
   * @param leftField 左边字段枚举
   * @param beginField 区间开始字段枚举
   * @param endField 区间结束字段
   * @return 具体实现
   */
  C between(Enum<?> leftField, Enum<?> beginField, String endField);

  /**
   * 区间条件
   *
   * @param condition 条件
   * @param leftField 左边字段名称
   * @param beginField 区间开始字段名称
   * @param endField 区间结束字段名称
   * @return 具体实现
   */
  default C between(boolean condition, String leftField, String beginField, String endField) {
    if (condition) {
      return this.between(leftField, beginField, endField);
    }

    return (C) this;
  }

  /**
   * 区间条件
   *
   * @param condition 条件
   * @param leftField 左边字段名称
   * @param beginField 区间开始字段枚举
   * @param endField 区间结束字段枚举
   * @return 具体实现
   */
  default C between(boolean condition, String leftField, Enum<?> beginField, Enum<?> endField) {
    if (condition) {
      return this.between(leftField, beginField, endField);
    }

    return (C) this;
  }

  /**
   * 区间条件
   *
   * @param condition 条件
   * @param leftField 左边字段名称
   * @param beginField 区间开始字段名称
   * @param endField 区间结束字段枚举
   * @return 具体实现
   */
  default C between(boolean condition, String leftField, String beginField, Enum<?> endField) {
    if (condition) {
      return this.between(leftField, beginField, endField);
    }

    return (C) this;
  }

  /**
   * 区间条件
   *
   * @param condition 条件
   * @param leftField 左边字段名称
   * @param beginField 区间开始字段枚举
   * @param endField 区间结束字段名称
   * @return 具体实现
   */
  default C between(boolean condition, String leftField, Enum<?> beginField, String endField) {
    if (condition) {
      return this.between(leftField, beginField, endField);
    }

    return (C) this;
  }

  /**
   * 区间条件
   *
   * @param condition 条件
   * @param leftField 左边字段枚举
   * @param beginField 区间开始字段枚举
   * @param endField 区间结束字段枚举
   * @return 具体实现
   */
  default C between(boolean condition, Enum<?> leftField, Enum<?> beginField, Enum<?> endField) {
    if (condition) {
      return this.between(leftField, beginField, endField);
    }

    return (C) this;
  }

  /**
   * 区间条件
   *
   * @param condition 条件
   * @param leftField 左边字段枚举
   * @param beginField 区间开始字段
   * @param endField 区间结束字段枚举
   * @return 具体实现
   */
  default C between(boolean condition, Enum<?> leftField, String beginField, Enum<?> endField) {
    if (condition) {
      return this.between(leftField, beginField, endField);
    }

    return (C) this;
  }

  /**
   * 区间条件
   *
   * @param condition 条件
   * @param leftField 左边字段枚举
   * @param beginField 区间开始字段枚举
   * @param endField 区间结束字段
   * @return 具体实现
   */
  default C between(boolean condition, Enum<?> leftField, Enum<?> beginField, String endField) {
    if (condition) {
      return this.between(leftField, beginField, endField);
    }

    return (C) this;
  }

  /**
   * 区间条件
   *
   * @param leftField 左边字段名称
   * @param beginValue 区间开始值
   * @param endField 区间结束字段名称
   * @return 具体实现
   */
  C betweenBeginValue(String leftField, Object beginValue, String endField);

  /**
   * 区间条件
   *
   * @param leftField 左边字段枚举
   * @param beginValue 区间开始值
   * @param endField 区间结束字段枚举
   * @return 具体实现
   */
  C betweenBeginValue(Enum<?> leftField, Object beginValue, Enum<?> endField);

  /**
   * 区间条件
   *
   * @param condition 条件
   * @param leftField 左边字段名称
   * @param beginValue 区间开始值
   * @param endField 区间结束字段名称
   * @return 具体实现
   */
  default C betweenBeginValue(
      boolean condition, String leftField, Object beginValue, String endField) {
    if (condition) {
      return this.betweenBeginValue(leftField, beginValue, endField);
    }

    return (C) this;
  }

  /**
   * 区间条件
   *
   * @param condition 条件
   * @param leftField 左边字段枚举
   * @param beginValue 区间开始值
   * @param endField 区间结束字段枚举
   * @return 具体实现
   */
  default C betweenBeginValue(
      boolean condition, Enum<?> leftField, Object beginValue, Enum<?> endField) {
    if (condition) {
      return this.betweenBeginValue(leftField, beginValue, endField);
    }

    return (C) this;
  }

  /**
   * 区间条件
   *
   * @param leftField 左边字段名称
   * @param beginField 区间开始字段名称
   * @param endValue 区间结束值
   * @return 具体实现
   */
  C betweenEndValue(String leftField, String beginField, Object endValue);

  /**
   * 区间条件
   *
   * @param leftField 左边字段枚举
   * @param beginField 区间开始字段枚举
   * @param endValue 区间结束值
   * @return 具体实现
   */
  C betweenEndValue(Enum<?> leftField, Enum<?> beginField, Object endValue);

  /**
   * 区间条件
   *
   * @param condition 条件
   * @param leftField 左边字段名称
   * @param beginField 区间开始字段名称
   * @param endValue 区间结束值
   * @return 具体实现
   */
  default C betweenEndValue(
      boolean condition, String leftField, String beginField, Object endValue) {
    if (condition) {
      return this.betweenEndValue(leftField, beginField, endValue);
    }

    return (C) this;
  }

  /**
   * 区间条件
   *
   * @param condition 条件
   * @param leftField 左边字段枚举
   * @param beginField 区间开始字段枚举
   * @param endValue 区间结束值
   * @return 具体实现
   */
  default C betweenEndValue(
      boolean condition, Enum<?> leftField, Enum<?> beginField, Object endValue) {
    if (condition) {
      return this.betweenEndValue(leftField, beginField, endValue);
    }

    return (C) this;
  }

  /**
   * 区间条件
   *
   * @param leftField 左边字段名称
   * @param beginValue 区间开始值
   * @param endValue 区间结束值
   * @return 具体实现
   */
  C betweenValue(String leftField, Object beginValue, Object endValue);

  /**
   * 区间条件
   *
   * @param leftField 左边字段枚举
   * @param beginValue 区间开始值
   * @param endValue 区间结束值
   * @return 具体实现
   */
  C betweenValue(Enum<?> leftField, Object beginValue, Object endValue);

  /**
   * 区间条件
   *
   * @param leftTableAlias 左边字段表别名
   * @param leftField 左边字段枚举
   * @param beginValue 区间开始值
   * @param endValue 区间结束值
   * @return 具体实现
   */
  C betweenValue(String leftTableAlias, Enum<?> leftField, Object beginValue, Object endValue);

  /**
   * 区间条件
   *
   * @param condition 条件
   * @param leftField 左边字段名称
   * @param beginValue 区间开始值
   * @param endValue 区间结束值
   * @return 具体实现
   */
  default C betweenValue(boolean condition, String leftField, Object beginValue, Object endValue) {
    if (condition) {
      return this.betweenValue(leftField, beginValue, endValue);
    }

    return (C) this;
  }

  /**
   * 区间条件
   *
   * @param condition 条件
   * @param leftField 左边字段枚举
   * @param beginValue 区间开始值
   * @param endValue 区间结束值
   * @return 具体实现
   */
  default C betweenValue(boolean condition, Enum<?> leftField, Object beginValue, Object endValue) {
    if (condition) {
      return this.betweenValue(leftField, beginValue, endValue);
    }

    return (C) this;
  }

  /**
   * 区间条件
   *
   * @param condition 条件
   * @param leftTableAlias 左边字段表别名
   * @param leftField 左边字段枚举
   * @param beginValue 区间开始值
   * @param endValue 区间结束值
   * @return 具体实现
   */
  default C betweenValue(
      boolean condition,
      String leftTableAlias,
      Enum<?> leftField,
      Object beginValue,
      Object endValue) {
    if (condition) {
      return this.betweenValue(leftTableAlias, leftField, beginValue, endValue);
    }

    return (C) this;
  }

  /**
   * 非区间条件
   *
   * @param leftField 左边字段名称
   * @param beginField 区间开始字段名称
   * @param endField 区间结束字段名称
   * @return 具体实现
   */
  C notBetween(String leftField, String beginField, String endField);

  /**
   * 非区间条件
   *
   * @param leftField 左边字段名称
   * @param beginField 区间开始字段枚举
   * @param endField 区间结束字段枚举
   * @return 具体实现
   */
  C notBetween(String leftField, Enum<?> beginField, Enum<?> endField);

  /**
   * 非区间条件
   *
   * @param leftField 左边字段名称
   * @param beginField 区间开始字段名称
   * @param endField 区间结束字段枚举
   * @return 具体实现
   */
  C notBetween(String leftField, String beginField, Enum<?> endField);

  /**
   * 非区间条件
   *
   * @param leftField 左边字段名称
   * @param beginField 区间开始字段枚举
   * @param endField 区间结束字段名称
   * @return 具体实现
   */
  C notBetween(String leftField, Enum<?> beginField, String endField);

  /**
   * 非区间条件
   *
   * @param leftField 左边字段枚举
   * @param beginField 区间开始字段枚举
   * @param endField 区间结束字段枚举
   * @return 具体实现
   */
  C notBetween(Enum<?> leftField, Enum<?> beginField, Enum<?> endField);

  /**
   * 非区间条件
   *
   * @param leftField 左边字段枚举
   * @param beginField 区间开始字段
   * @param endField 区间结束字段枚举
   * @return 具体实现
   */
  C notBetween(Enum<?> leftField, String beginField, Enum<?> endField);

  /**
   * 非区间条件
   *
   * @param leftField 左边字段枚举
   * @param beginField 区间开始字段枚举
   * @param endField 区间结束字段
   * @return 具体实现
   */
  C notBetween(Enum<?> leftField, Enum<?> beginField, String endField);

  /**
   * 非区间条件
   *
   * @param condition 条件
   * @param leftField 左边字段名称
   * @param beginField 区间开始字段名称
   * @param endField 区间结束字段名称
   * @return 具体实现
   */
  default C notBetween(boolean condition, String leftField, String beginField, String endField) {
    if (condition) {
      return this.notBetween(leftField, beginField, endField);
    }

    return (C) this;
  }

  /**
   * 非区间条件
   *
   * @param condition 条件
   * @param leftField 左边字段名称
   * @param beginField 区间开始字段枚举
   * @param endField 区间结束字段枚举
   * @return 具体实现
   */
  default C notBetween(boolean condition, String leftField, Enum<?> beginField, Enum<?> endField) {
    if (condition) {
      return this.notBetween(leftField, beginField, endField);
    }

    return (C) this;
  }

  /**
   * 非区间条件
   *
   * @param condition 条件
   * @param leftField 左边字段名称
   * @param beginField 区间开始字段名称
   * @param endField 区间结束字段枚举
   * @return 具体实现
   */
  default C notBetween(boolean condition, String leftField, String beginField, Enum<?> endField) {
    if (condition) {
      return this.notBetween(leftField, beginField, endField);
    }

    return (C) this;
  }

  /**
   * 非区间条件
   *
   * @param condition 条件
   * @param leftField 左边字段名称
   * @param beginField 区间开始字段枚举
   * @param endField 区间结束字段名称
   * @return 具体实现
   */
  default C notBetween(boolean condition, String leftField, Enum<?> beginField, String endField) {
    if (condition) {
      return this.notBetween(leftField, beginField, endField);
    }

    return (C) this;
  }

  /**
   * 非区间条件
   *
   * @param condition 条件
   * @param leftField 左边字段枚举
   * @param beginField 区间开始字段枚举
   * @param endField 区间结束字段枚举
   * @return 具体实现
   */
  default C notBetween(boolean condition, Enum<?> leftField, Enum<?> beginField, Enum<?> endField) {
    if (condition) {
      return this.notBetween(leftField, beginField, endField);
    }

    return (C) this;
  }

  /**
   * 非区间条件
   *
   * @param condition 条件
   * @param leftField 左边字段枚举
   * @param beginField 区间开始字段名称
   * @param endField 区间结束字段枚举
   * @return 具体实现
   */
  default C notBetween(boolean condition, Enum<?> leftField, String beginField, Enum<?> endField) {
    if (condition) {
      return this.notBetween(leftField, beginField, endField);
    }

    return (C) this;
  }

  /**
   * 非区间条件
   *
   * @param condition 条件
   * @param leftField 左边字段枚举
   * @param beginField 区间开始字段枚举
   * @param endField 区间结束字段名称
   * @return 具体实现
   */
  default C notBetween(boolean condition, Enum<?> leftField, Enum<?> beginField, String endField) {
    if (condition) {
      return this.notBetween(leftField, beginField, endField);
    }

    return (C) this;
  }

  /**
   * 非区间条件
   *
   * @param leftField 左边字段名称
   * @param beginValue 区间开始值
   * @param endField 区间结束字段名称
   * @return 具体实现
   */
  C notBetweenBeginValue(String leftField, Object beginValue, String endField);

  /**
   * 非区间条件
   *
   * @param leftField 左边字段枚举
   * @param beginValue 区间开始值
   * @param endField 区间结束字段枚举
   * @return 具体实现
   */
  C notBetweenBeginValue(Enum<?> leftField, Object beginValue, Enum<?> endField);

  /**
   * 非区间条件
   *
   * @param condition 条件
   * @param leftField 左边字段名称
   * @param beginValue 区间开始值
   * @param endField 区间结束字段名称
   * @return 具体实现
   */
  default C notBetweenBeginValue(
      boolean condition, String leftField, Object beginValue, String endField) {
    if (condition) {
      return this.notBetweenBeginValue(leftField, beginValue, endField);
    }

    return (C) this;
  }

  /**
   * 非区间条件
   *
   * @param condition 条件
   * @param leftField 左边字段枚举
   * @param beginValue 区间开始值
   * @param endField 区间结束字段枚举
   * @return 具体实现
   */
  default C notBetweenBeginValue(
      boolean condition, Enum<?> leftField, Object beginValue, Enum<?> endField) {
    if (condition) {
      return this.notBetweenBeginValue(leftField, beginValue, endField);
    }

    return (C) this;
  }

  /**
   * 非区间条件
   *
   * @param leftField 左边字段名称
   * @param beginField 区间开始字段名称
   * @param endValue 区间结束值
   * @return 具体实现
   */
  C notBetweenEndValue(String leftField, String beginField, Object endValue);

  /**
   * 非区间条件
   *
   * @param leftField 左边字段枚举
   * @param beginField 区间开始字段枚举
   * @param endValue 区间结束值
   * @return 具体实现
   */
  C notBetweenEndValue(Enum<?> leftField, Enum<?> beginField, Object endValue);

  /**
   * 非区间条件
   *
   * @param condition 条件
   * @param leftField 左边字段名称
   * @param beginField 区间开始字段名称
   * @param endValue 区间结束值
   * @return 具体实现
   */
  default C notBetweenEndValue(
      boolean condition, String leftField, String beginField, Object endValue) {
    if (condition) {
      return this.notBetweenEndValue(leftField, beginField, endValue);
    }

    return (C) this;
  }

  /**
   * 非区间条件
   *
   * @param condition 条件
   * @param leftField 左边字段枚举
   * @param beginField 区间开始字段枚举
   * @param endValue 区间结束值
   * @return 具体实现
   */
  default C notBetweenEndValue(
      boolean condition, Enum<?> leftField, Enum<?> beginField, Object endValue) {
    if (condition) {
      return this.notBetweenEndValue(leftField, beginField, endValue);
    }

    return (C) this;
  }

  /**
   * 非区间条件
   *
   * @param leftField 左边字段名称
   * @param beginValue 区间开始值
   * @param endValue 区间结束值
   * @return 具体实现
   */
  C notBetweenValue(String leftField, Object beginValue, Object endValue);

  /**
   * 非区间条件
   *
   * @param leftField 左边字段枚举
   * @param beginValue 区间开始值
   * @param endValue 区间结束值
   * @return 具体实现
   */
  C notBetweenValue(Enum<?> leftField, Object beginValue, Object endValue);

  /**
   * 非区间条件
   *
   * @param leftTableAlias 左边字段表别名
   * @param leftField 左边字段枚举
   * @param beginValue 区间开始值
   * @param endValue 区间结束值
   * @return 具体实现
   */
  C notBetweenValue(String leftTableAlias, Enum<?> leftField, Object beginValue, Object endValue);

  /**
   * 非区间条件
   *
   * @param condition 条件
   * @param leftField 左边字段名称
   * @param beginValue 区间开始值
   * @param endValue 区间结束值
   * @return 具体实现
   */
  default C notBetweenValue(
      boolean condition, String leftField, Object beginValue, Object endValue) {
    if (condition) {
      return this.notBetweenValue(leftField, beginValue, endValue);
    }

    return (C) this;
  }

  /**
   * 非区间条件
   *
   * @param condition 条件
   * @param leftField 左边字段枚举
   * @param beginValue 区间开始值
   * @param endValue 区间结束值
   * @return 具体实现
   */
  default C notBetweenValue(
      boolean condition, Enum<?> leftField, Object beginValue, Object endValue) {
    if (condition) {
      return this.notBetweenValue(leftField, beginValue, endValue);
    }

    return (C) this;
  }

  /**
   * 非区间条件
   *
   * @param condition 条件
   * @param leftTableAlias 左边字段表别名
   * @param leftField 左边字段枚举
   * @param beginValue 区间开始值
   * @param endValue 区间结束值
   * @return 具体实现
   */
  default C notBetweenValue(
      boolean condition,
      String leftTableAlias,
      Enum<?> leftField,
      Object beginValue,
      Object endValue) {
    if (condition) {
      return this.notBetweenValue(leftTableAlias, leftField, beginValue, endValue);
    }

    return (C) this;
  }

  /**
   * 范围条件
   *
   * @param leftField 左边字段名称
   * @param rightFields 范围字段名称
   * @return 具体实现
   */
  C in(String leftField, String... rightFields);

  /**
   * 范围条件
   *
   * @param leftField 左边字段枚举
   * @param rightFields 范围字段枚举
   * @return 具体实现
   */
  C in(Enum<?> leftField, Enum<?>... rightFields);

  /**
   * 范围条件
   *
   * @param leftField 左边字段名称
   * @param rightFields 范围字段名称
   * @return 具体实现
   */
  C in(String leftField, Collection<String> rightFields);

  /**
   * 范围条件
   *
   * @param leftField 左边字段枚举
   * @param rightFields 范围字段枚举
   * @return 具体实现
   */
  C in(Enum<?> leftField, Collection<Enum<?>> rightFields);

  /**
   * 范围条件
   *
   * @param leftField 左边字段名称
   * @param rightFields 范围字段名称
   * @param rightValues 范围值
   * @return 具体实现
   */
  C in(String leftField, Collection<String> rightFields, Collection<?> rightValues);

  /**
   * 范围条件
   *
   * @param leftField 左边字段枚举
   * @param rightFields 范围字段枚举
   * @param rightValues 范围值
   * @return 具体实现
   */
  C in(Enum<?> leftField, Collection<Enum<?>> rightFields, Collection<?> rightValues);

  /**
   * 范围条件
   *
   * @param leftField 左边字段名称
   * @param sqlBuilderConsumer SQL构建器消费器
   * @return 具体实现
   */
  C in(String leftField, Consumer<StandardSelectSql> sqlBuilderConsumer);

  /**
   * 范围条件
   *
   * @param leftField 左边字段枚举
   * @param sqlBuilderConsumer SQL构建器消费器
   * @return 具体实现
   */
  C in(Enum<?> leftField, Consumer<StandardSelectSql> sqlBuilderConsumer);

  /**
   * 范围条件
   *
   * @param leftTableAlias 左边字段表别名
   * @param leftField 左边字段枚举
   * @param sqlBuilderConsumer SQL构建器消费器
   * @return 具体实现
   */
  C in(String leftTableAlias, Enum<?> leftField, Consumer<StandardSelectSql> sqlBuilderConsumer);

  /**
   * 范围条件
   *
   * @param condition 条件
   * @param leftField 左边字段名称
   * @param rightFields 范围字段名称
   * @return 具体实现
   */
  default C in(boolean condition, String leftField, String... rightFields) {
    if (condition) {
      return this.in(leftField, rightFields);
    }

    return (C) this;
  }

  /**
   * 范围条件
   *
   * @param condition 条件
   * @param leftField 左边字段枚举
   * @param rightFields 范围字段枚举
   * @return 具体实现
   */
  default C in(boolean condition, Enum<?> leftField, Enum<?>... rightFields) {
    if (condition) {
      return this.in(leftField, rightFields);
    }

    return (C) this;
  }

  /**
   * 范围条件
   *
   * @param condition 条件
   * @param leftField 左边字段名称
   * @param rightFields 范围字段名称
   * @return 具体实现
   */
  default C in(boolean condition, String leftField, Collection<String> rightFields) {
    if (condition) {
      return this.in(leftField, rightFields);
    }

    return (C) this;
  }

  /**
   * 范围条件
   *
   * @param condition 条件
   * @param leftField 左边字段枚举
   * @param rightFields 范围字段枚举
   * @return 具体实现
   */
  default C in(boolean condition, Enum<?> leftField, Collection<Enum<?>> rightFields) {
    if (condition) {
      return this.in(leftField, rightFields);
    }

    return (C) this;
  }

  /**
   * 范围条件
   *
   * @param condition 条件
   * @param leftField 左边字段名称
   * @param rightFields 范围字段名称
   * @param rightValues 范围值
   * @return 具体实现
   */
  default C in(
      boolean condition,
      String leftField,
      Collection<String> rightFields,
      Collection<?> rightValues) {
    if (condition) {
      return this.in(leftField, rightFields, rightValues);
    }

    return (C) this;
  }

  /**
   * 范围条件
   *
   * @param condition 条件
   * @param leftField 左边字段枚举
   * @param rightFields 范围字段枚举
   * @param rightValues 范围值
   * @return 具体实现
   */
  default C in(
      boolean condition,
      Enum<?> leftField,
      Collection<Enum<?>> rightFields,
      Collection<?> rightValues) {
    if (condition) {
      return this.in(leftField, rightFields, rightValues);
    }

    return (C) this;
  }

  /**
   * 范围条件
   *
   * @param condition 条件
   * @param leftField 左边字段名称
   * @param sqlBuilderConsumer SQL构建器消费器
   * @return 具体实现
   */
  default C in(
      boolean condition, String leftField, Consumer<StandardSelectSql> sqlBuilderConsumer) {
    if (condition) {
      return this.in(leftField, sqlBuilderConsumer);
    }

    return (C) this;
  }

  /**
   * 范围条件
   *
   * @param condition 条件
   * @param leftField 左边字段枚举
   * @param sqlBuilderConsumer SQL构建器消费器
   * @return 具体实现
   */
  default C in(
      boolean condition, Enum<?> leftField, Consumer<StandardSelectSql> sqlBuilderConsumer) {
    if (condition) {
      return this.in(leftField, sqlBuilderConsumer);
    }

    return (C) this;
  }

  /**
   * 范围条件
   *
   * @param condition 条件
   * @param leftTableAlias 左边字段表别名
   * @param leftField 左边字段枚举
   * @param sqlBuilderConsumer SQL构建器消费器
   * @return 具体实现
   */
  default C in(
      boolean condition,
      String leftTableAlias,
      Enum<?> leftField,
      Consumer<StandardSelectSql> sqlBuilderConsumer) {
    if (condition) {
      return this.in(leftTableAlias, leftField, sqlBuilderConsumer);
    }

    return (C) this;
  }

  /**
   * 范围条件
   *
   * @param leftField 左边字段名称
   * @param rightValues 范围值
   * @return 具体实现
   */
  C inValue(String leftField, Object... rightValues);

  /**
   * 范围条件
   *
   * @param leftField 左边字段枚举
   * @param rightValues 范围值
   * @return 具体实现
   */
  C inValue(Enum<?> leftField, Object... rightValues);

  /**
   * 范围条件
   *
   * @param leftTableAlias 左边字段表别名
   * @param leftField 左边字段枚举
   * @param rightValues 范围值
   * @return 具体实现
   */
  C inValue(String leftTableAlias, Enum<?> leftField, Object... rightValues);

  /**
   * 范围条件
   *
   * @param leftField 左边字段名称
   * @param rightValues 范围值
   * @return 具体实现
   */
  C inValue(String leftField, Collection<?> rightValues);

  /**
   * 范围条件
   *
   * @param leftField 左边字段枚举
   * @param rightValues 范围值
   * @return 具体实现
   */
  C inValue(Enum<?> leftField, Collection<?> rightValues);

  /**
   * 范围条件
   *
   * @param leftTableAlias 左边字段表别名
   * @param leftField 左边字段枚举
   * @param rightValues 范围值
   * @return 具体实现
   */
  C inValue(String leftTableAlias, Enum<?> leftField, Collection<?> rightValues);

  /**
   * 范围条件
   *
   * @param condition 条件
   * @param leftField 左边字段名称
   * @param rightValues 范围值
   * @return 具体实现
   */
  default C inValue(boolean condition, String leftField, Object... rightValues) {
    if (condition) {
      return this.inValue(leftField, rightValues);
    }

    return (C) this;
  }

  /**
   * 范围条件
   *
   * @param condition 条件
   * @param leftField 左边字段枚举
   * @param rightValues 范围值
   * @return 具体实现
   */
  default C inValue(boolean condition, Enum<?> leftField, Object... rightValues) {
    if (condition) {
      return this.inValue(leftField, rightValues);
    }

    return (C) this;
  }

  /**
   * 范围条件
   *
   * @param condition 条件
   * @param leftTableAlias 左边字段表别名
   * @param leftField 左边字段枚举
   * @param rightValues 范围值
   * @return 具体实现
   */
  default C inValue(
      boolean condition, String leftTableAlias, Enum<?> leftField, Object... rightValues) {
    if (condition) {
      return this.inValue(leftTableAlias, leftField, rightValues);
    }

    return (C) this;
  }

  /**
   * 范围条件
   *
   * @param condition 条件
   * @param leftField 左边字段名称
   * @param rightValues 范围值
   * @return 具体实现
   */
  default C inValue(boolean condition, String leftField, Collection<?> rightValues) {
    if (condition) {
      return this.inValue(leftField, rightValues);
    }

    return (C) this;
  }

  /**
   * 范围条件
   *
   * @param condition 条件
   * @param leftField 左边字段枚举
   * @param rightValues 范围值
   * @return 具体实现
   */
  default C inValue(boolean condition, Enum<?> leftField, Collection<?> rightValues) {
    if (condition) {
      return this.inValue(leftField, rightValues);
    }

    return (C) this;
  }

  /**
   * 范围条件
   *
   * @param condition 条件
   * @param leftTableAlias 左边字段表别名
   * @param leftField 左边字段枚举
   * @param rightValues 范围值
   * @return 具体实现
   */
  default C inValue(
      boolean condition, String leftTableAlias, Enum<?> leftField, Collection<?> rightValues) {
    if (condition) {
      return this.inValue(leftTableAlias, leftField, rightValues);
    }

    return (C) this;
  }

  /**
   * 非范围条件
   *
   * @param leftField 左边字段名称
   * @param rightFields 范围字段名称
   * @return 具体实现
   */
  C notIn(String leftField, String... rightFields);

  /**
   * 非范围条件
   *
   * @param leftField 左边字段枚举
   * @param rightFields 范围字段枚举
   * @return 具体实现
   */
  C notIn(Enum<?> leftField, Enum<?>... rightFields);

  /**
   * 非范围条件
   *
   * @param leftField 左边字段名称
   * @param rightFields 范围字段名称
   * @return 具体实现
   */
  C notIn(String leftField, Collection<String> rightFields);

  /**
   * 非范围条件
   *
   * @param leftField 左边字段枚举
   * @param rightFields 范围字段枚举
   * @return 具体实现
   */
  C notIn(Enum<?> leftField, Collection<Enum<?>> rightFields);

  /**
   * 非范围条件
   *
   * @param leftField 左边字段名称
   * @param rightFields 范围字段名称
   * @param rightValues 范围值
   * @return 具体实现
   */
  C notIn(String leftField, Collection<String> rightFields, Collection<?> rightValues);

  /**
   * 非范围条件
   *
   * @param leftField 左边字段枚举
   * @param rightFields 范围字段枚举
   * @param rightValues 范围值
   * @return 具体实现
   */
  C notIn(Enum<?> leftField, Collection<Enum<?>> rightFields, Collection<?> rightValues);

  /**
   * 非范围条件
   *
   * @param leftField 左边字段名称
   * @param sqlBuilderConsumer SQL构建器消费器
   * @return 具体实现
   */
  C notIn(String leftField, Consumer<StandardSelectSql> sqlBuilderConsumer);

  /**
   * 非范围条件
   *
   * @param leftField 左边字段枚举
   * @param sqlBuilderConsumer SQL构建器消费器
   * @return 具体实现
   */
  C notIn(Enum<?> leftField, Consumer<StandardSelectSql> sqlBuilderConsumer);

  /**
   * 非范围条件
   *
   * @param leftTableAlias 左边字段表别名
   * @param leftField 左边字段枚举
   * @param sqlBuilderConsumer SQL构建器消费器
   * @return 具体实现
   */
  C notIn(String leftTableAlias, Enum<?> leftField, Consumer<StandardSelectSql> sqlBuilderConsumer);

  /**
   * 非范围条件
   *
   * @param condition 条件
   * @param leftField 左边字段名称
   * @param rightFields 范围字段名称
   * @return 具体实现
   */
  default C notIn(boolean condition, String leftField, String... rightFields) {
    if (condition) {
      return this.notIn(leftField, rightFields);
    }

    return (C) this;
  }

  /**
   * 非范围条件
   *
   * @param condition 条件
   * @param leftField 左边字段枚举
   * @param rightFields 范围字段枚举
   * @return 具体实现
   */
  default C notIn(boolean condition, Enum<?> leftField, Enum<?>... rightFields) {
    if (condition) {
      return this.notIn(leftField, rightFields);
    }

    return (C) this;
  }

  /**
   * 非范围条件
   *
   * @param condition 条件
   * @param leftField 左边字段名称
   * @param rightFields 范围字段名称
   * @return 具体实现
   */
  default C notIn(boolean condition, String leftField, Collection<String> rightFields) {
    if (condition) {
      return this.notIn(leftField, rightFields);
    }

    return (C) this;
  }

  /**
   * 非范围条件
   *
   * @param condition 条件
   * @param leftField 左边字段枚举
   * @param rightFields 范围字段枚举
   * @return 具体实现
   */
  default C notIn(boolean condition, Enum<?> leftField, Collection<Enum<?>> rightFields) {
    if (condition) {
      return this.notIn(leftField, rightFields);
    }

    return (C) this;
  }

  /**
   * 非范围条件
   *
   * @param condition 条件
   * @param leftField 左边字段名称
   * @param rightFields 范围字段名称
   * @param rightValues 范围值
   * @return 具体实现
   */
  default C notIn(
      boolean condition,
      String leftField,
      Collection<String> rightFields,
      Collection<?> rightValues) {
    if (condition) {
      return this.notIn(leftField, rightFields, rightValues);
    }

    return (C) this;
  }

  /**
   * 非范围条件
   *
   * @param condition 条件
   * @param leftField 左边字段枚举
   * @param rightFields 范围字段枚举
   * @param rightValues 范围值
   * @return 具体实现
   */
  default C notIn(
      boolean condition,
      Enum<?> leftField,
      Collection<Enum<?>> rightFields,
      Collection<?> rightValues) {
    if (condition) {
      return this.notIn(leftField, rightFields, rightValues);
    }

    return (C) this;
  }

  /**
   * 非范围条件
   *
   * @param condition 条件
   * @param leftField 左边字段名称
   * @param sqlBuilderConsumer SQL构建器消费器
   * @return 具体实现
   */
  default C notIn(
      boolean condition, String leftField, Consumer<StandardSelectSql> sqlBuilderConsumer) {
    if (condition) {
      return this.notIn(leftField, sqlBuilderConsumer);
    }

    return (C) this;
  }

  /**
   * 非范围条件
   *
   * @param condition 条件
   * @param leftField 左边字段枚举
   * @param sqlBuilderConsumer SQL构建器消费器
   * @return 具体实现
   */
  default C notIn(
      boolean condition, Enum<?> leftField, Consumer<StandardSelectSql> sqlBuilderConsumer) {
    if (condition) {
      return this.notIn(leftField, sqlBuilderConsumer);
    }

    return (C) this;
  }

  /**
   * 非范围条件
   *
   * @param condition 条件
   * @param leftTableAlias 左边字段表别名
   * @param leftField 左边字段枚举
   * @param sqlBuilderConsumer SQL构建器消费器
   * @return 具体实现
   */
  default C notIn(
      boolean condition,
      String leftTableAlias,
      Enum<?> leftField,
      Consumer<StandardSelectSql> sqlBuilderConsumer) {
    if (condition) {
      return this.notIn(leftTableAlias, leftField, sqlBuilderConsumer);
    }

    return (C) this;
  }

  /**
   * 非范围条件
   *
   * @param leftField 左边字段名称
   * @param rightValues 范围值
   * @return 具体实现
   */
  C notInValue(String leftField, Object... rightValues);

  /**
   * 非范围条件
   *
   * @param leftField 左边字段枚举
   * @param rightValues 范围值
   * @return 具体实现
   */
  C notInValue(Enum<?> leftField, Object... rightValues);

  /**
   * 非范围条件
   *
   * @param leftTableAlias 左边字段表别名
   * @param leftField 左边字段枚举
   * @param rightValues 范围值
   * @return 具体实现
   */
  C notInValue(String leftTableAlias, Enum<?> leftField, Object... rightValues);

  /**
   * 非范围条件
   *
   * @param leftField 左边字段名称
   * @param rightValues 范围值
   * @return 具体实现
   */
  C notInValue(String leftField, Collection<?> rightValues);

  /**
   * 非范围条件
   *
   * @param leftField 左边字段枚举
   * @param rightValues 范围值
   * @return 具体实现
   */
  C notInValue(Enum<?> leftField, Collection<?> rightValues);

  /**
   * 非范围条件
   *
   * @param leftTableAlias 左边字段表别名
   * @param leftField 左边字段枚举
   * @param rightValues 范围值
   * @return 具体实现
   */
  C notInValue(String leftTableAlias, Enum<?> leftField, Collection<?> rightValues);

  /**
   * 非范围条件
   *
   * @param condition 条件
   * @param leftField 左边字段名称
   * @param rightValues 范围值
   * @return 具体实现
   */
  default C notInValue(boolean condition, String leftField, Object... rightValues) {
    if (condition) {
      return this.notInValue(leftField, rightValues);
    }

    return (C) this;
  }

  /**
   * 非范围条件
   *
   * @param condition 条件
   * @param leftField 左边字段枚举
   * @param rightValues 范围值
   * @return 具体实现
   */
  default C notInValue(boolean condition, Enum<?> leftField, Object... rightValues) {
    if (condition) {
      return this.notInValue(leftField, rightValues);
    }

    return (C) this;
  }

  /**
   * 非范围条件
   *
   * @param condition 条件
   * @param leftTableAlias 左边字段表别名
   * @param leftField 左边字段枚举
   * @param rightValues 范围值
   * @return 具体实现
   */
  default C notInValue(
      boolean condition, String leftTableAlias, Enum<?> leftField, Object... rightValues) {
    if (condition) {
      return this.notInValue(leftTableAlias, leftField, rightValues);
    }

    return (C) this;
  }

  /**
   * 非范围条件
   *
   * @param condition 条件
   * @param leftField 左边字段名称
   * @param rightValues 范围值
   * @return 具体实现
   */
  default C notInValue(boolean condition, String leftField, Collection<?> rightValues) {
    if (condition) {
      return this.notInValue(leftField, rightValues);
    }

    return (C) this;
  }

  /**
   * 非范围条件
   *
   * @param condition 条件
   * @param leftField 左边字段枚举
   * @param rightValues 范围值
   * @return 具体实现
   */
  default C notInValue(boolean condition, Enum<?> leftField, Collection<?> rightValues) {
    if (condition) {
      return this.notInValue(leftField, rightValues);
    }

    return (C) this;
  }

  /**
   * 非范围条件
   *
   * @param condition 条件
   * @param leftTableAlias 左边字段表别名
   * @param leftField 左边字段枚举
   * @param rightValues 范围值
   * @return 具体实现
   */
  default C notInValue(
      boolean condition, String leftTableAlias, Enum<?> leftField, Collection<?> rightValues) {
    if (condition) {
      return this.notInValue(leftTableAlias, leftField, rightValues);
    }

    return (C) this;
  }

  /**
   * 为空条件
   *
   * @param field 字段名称
   * @return 具体实现
   */
  C isNull(String field);

  /**
   * 为空条件
   *
   * @param field 字段枚举
   * @return 具体实现
   */
  C isNull(Enum<?> field);

  /**
   * 为空条件
   *
   * @param tableAlias 字段表别名
   * @param field 字段枚举
   * @return 具体实现
   */
  C isNull(String tableAlias, Enum<?> field);

  /**
   * 为空条件
   *
   * @param sqlBuilderConsumer SQL构建器消费器
   * @return 具体实现
   */
  C isNull(Consumer<StandardSelectSql> sqlBuilderConsumer);

  /**
   * 为空条件
   *
   * @param condition 条件
   * @param field 字段名称
   * @return 具体实现
   */
  default C isNull(boolean condition, String field) {
    if (condition) {
      return this.isNull(field);
    }

    return (C) this;
  }

  /**
   * 为空条件
   *
   * @param condition 条件
   * @param field 字段枚举
   * @return 具体实现
   */
  default C isNull(boolean condition, Enum<?> field) {
    if (condition) {
      return this.isNull(field);
    }

    return (C) this;
  }

  /**
   * 为空条件
   *
   * @param condition 条件
   * @param tableAlias 字段表别名
   * @param field 字段枚举
   * @return 具体实现
   */
  default C isNull(boolean condition, String tableAlias, Enum<?> field) {
    if (condition) {
      return this.isNull(tableAlias, field);
    }

    return (C) this;
  }

  /**
   * 为空条件
   *
   * @param condition 条件
   * @param sqlBuilderConsumer SQL构建器消费器
   * @return 具体实现
   */
  default C isNull(boolean condition, Consumer<StandardSelectSql> sqlBuilderConsumer) {
    if (condition) {
      return this.isNull(sqlBuilderConsumer);
    }

    return (C) this;
  }

  /**
   * 非空条件
   *
   * @param field 字段名称
   * @return 具体实现
   */
  C isNotNull(String field);

  /**
   * 非空条件
   *
   * @param field 字段枚举
   * @return 具体实现
   */
  C isNotNull(Enum<?> field);

  /**
   * 非空条件
   *
   * @param tableAlias 字段表别名
   * @param field 字段枚举
   * @return 具体实现
   */
  C isNotNull(String tableAlias, Enum<?> field);

  /**
   * 非空条件
   *
   * @param sqlBuilderConsumer SQL构建器消费器
   * @return 具体实现
   */
  C isNotNull(Consumer<StandardSelectSql> sqlBuilderConsumer);

  /**
   * 非空条件
   *
   * @param condition 条件
   * @param field 字段名称
   * @return 具体实现
   */
  default C isNotNull(boolean condition, String field) {
    if (condition) {
      return this.isNotNull(field);
    }

    return (C) this;
  }

  /**
   * 非空条件
   *
   * @param condition 条件
   * @param field 字段枚举
   * @return 具体实现
   */
  default C isNotNull(boolean condition, Enum<?> field) {
    if (condition) {
      return this.isNotNull(field);
    }

    return (C) this;
  }

  /**
   * 非空条件
   *
   * @param condition 条件
   * @param tableAlias 字段表别名
   * @param field 字段枚举
   * @return 具体实现
   */
  default C isNotNull(boolean condition, String tableAlias, Enum<?> field) {
    if (condition) {
      return this.isNotNull(tableAlias, field);
    }

    return (C) this;
  }

  /**
   * 非空条件
   *
   * @param condition 条件
   * @param sqlBuilderConsumer SQL构建器消费器
   * @return 具体实现
   */
  default C isNotNull(boolean condition, Consumer<StandardSelectSql> sqlBuilderConsumer) {
    if (condition) {
      return this.isNotNull(sqlBuilderConsumer);
    }

    return (C) this;
  }

  /**
   * 模糊匹配条件
   *
   * @param field 字段名称
   * @param value 匹配值
   * @return 具体实现
   */
  C like(String field, String value);

  /**
   * 模糊匹配条件
   *
   * @param field 字段枚举
   * @param value 匹配值
   * @return 具体实现
   */
  C like(Enum<?> field, String value);

  /**
   * 模糊匹配条件
   *
   * @param tableAlias 字段表别名
   * @param field 字段枚举
   * @param value 匹配值
   * @return 具体实现
   */
  C like(String tableAlias, Enum<?> field, String value);

  /**
   * 模糊匹配条件
   *
   * @param condition 条件
   * @param field 字段名称
   * @param value 匹配值
   * @return 具体实现
   */
  default C like(boolean condition, String field, String value) {
    if (condition) {
      return this.like(field, value);
    }

    return (C) this;
  }

  /**
   * 模糊匹配条件
   *
   * @param condition 条件
   * @param field 字段枚举
   * @param value 匹配值
   * @return 具体实现
   */
  default C like(boolean condition, Enum<?> field, String value) {
    if (condition) {
      return this.like(field, value);
    }

    return (C) this;
  }

  /**
   * 模糊匹配条件
   *
   * @param condition 条件
   * @param tableAlias 字段表别名
   * @param field 字段枚举
   * @param value 匹配值
   * @return 具体实现
   */
  default C like(boolean condition, String tableAlias, Enum<?> field, String value) {
    if (condition) {
      return this.like(tableAlias, field, value);
    }

    return (C) this;
  }

  /**
   * 左模糊匹配条件
   *
   * @param field 字段名称
   * @param value 匹配值
   * @return 具体实现
   */
  C likeLeft(String field, String value);

  /**
   * 左模糊匹配条件
   *
   * @param field 字段枚举
   * @param value 匹配值
   * @return 具体实现
   */
  C likeLeft(Enum<?> field, String value);

  /**
   * 左模糊匹配条件
   *
   * @param tableAlias 字段表别名
   * @param field 字段枚举
   * @param value 匹配值
   * @return 具体实现
   */
  C likeLeft(String tableAlias, Enum<?> field, String value);

  /**
   * 左模糊匹配条件
   *
   * @param condition 条件
   * @param field 字段名称
   * @param value 匹配值
   * @return 具体实现
   */
  default C likeLeft(boolean condition, String field, String value) {
    if (condition) {
      return this.likeLeft(field, value);
    }

    return (C) this;
  }

  /**
   * 左模糊匹配条件
   *
   * @param condition 条件
   * @param field 字段枚举
   * @param value 匹配值
   * @return 具体实现
   */
  default C likeLeft(boolean condition, Enum<?> field, String value) {
    if (condition) {
      return this.likeLeft(field, value);
    }

    return (C) this;
  }

  /**
   * 左模糊匹配条件
   *
   * @param condition 条件
   * @param tableAlias 表别名
   * @param field 字段枚举
   * @param value 匹配值
   * @return 具体实现
   */
  default C likeLeft(boolean condition, String tableAlias, Enum<?> field, String value) {
    if (condition) {
      return this.likeLeft(tableAlias, field, value);
    }

    return (C) this;
  }

  /**
   * 右模糊匹配条件
   *
   * @param field 字段名称
   * @param value 匹配值
   * @return 具体实现
   */
  C likeRight(String field, String value);

  /**
   * 右模糊匹配条件
   *
   * @param field 字段枚举
   * @param value 匹配值
   * @return 具体实现
   */
  C likeRight(Enum<?> field, String value);

  /**
   * 右模糊匹配条件
   *
   * @param tableAlias 字段表别名
   * @param field 字段枚举
   * @param value 匹配值
   * @return 具体实现
   */
  C likeRight(String tableAlias, Enum<?> field, String value);

  /**
   * 右模糊匹配条件
   *
   * @param condition 条件
   * @param field 字段名称
   * @param value 匹配值
   * @return 具体实现
   */
  default C likeRight(boolean condition, String field, String value) {
    if (condition) {
      return this.likeRight(field, value);
    }

    return (C) this;
  }

  /**
   * 右模糊匹配条件
   *
   * @param condition 条件
   * @param field 字段枚举
   * @param value 匹配值
   * @return 具体实现
   */
  default C likeRight(boolean condition, Enum<?> field, String value) {
    if (condition) {
      return this.likeRight(field, value);
    }

    return (C) this;
  }

  /**
   * 右模糊匹配条件
   *
   * @param condition 条件
   * @param tableAlias 字段表别名
   * @param field 字段枚举
   * @param value 匹配值
   * @return 具体实现
   */
  default C likeRight(boolean condition, String tableAlias, Enum<?> field, String value) {
    if (condition) {
      return this.likeRight(tableAlias, field, value);
    }

    return (C) this;
  }

  /**
   * 非模糊匹配条件
   *
   * @param field 字段名称
   * @param value 匹配值
   * @return 具体实现
   */
  C notLike(String field, String value);

  /**
   * 非模糊匹配条件
   *
   * @param field 字段枚举
   * @param value 匹配值
   * @return 具体实现
   */
  C notLike(Enum<?> field, String value);

  /**
   * 非模糊匹配条件
   *
   * @param tableAlias 字段表别名
   * @param field 字段枚举
   * @param value 匹配值
   * @return 具体实现
   */
  C notLike(String tableAlias, Enum<?> field, String value);

  /**
   * 非模糊匹配条件
   *
   * @param condition 条件
   * @param field 字段名称
   * @param value 匹配值
   * @return 具体实现
   */
  default C notLike(boolean condition, String field, String value) {
    if (condition) {
      return this.notLike(field, value);
    }

    return (C) this;
  }

  /**
   * 非模糊匹配条件
   *
   * @param condition 条件
   * @param field 字段枚举
   * @param value 匹配值
   * @return 具体实现
   */
  default C notLike(boolean condition, Enum<?> field, String value) {
    if (condition) {
      return this.notLike(field, value);
    }

    return (C) this;
  }

  /**
   * 非模糊匹配条件
   *
   * @param condition 条件
   * @param tableAlias 字段表别名
   * @param field 字段枚举
   * @param value 匹配值
   * @return 具体实现
   */
  default C notLike(boolean condition, String tableAlias, Enum<?> field, String value) {
    if (condition) {
      return this.notLike(tableAlias, field, value);
    }

    return (C) this;
  }

  /**
   * 非左模糊匹配条件
   *
   * @param field 字段名称
   * @param value 匹配值
   * @return 具体实现
   */
  C notLikeLeft(String field, String value);

  /**
   * 非左模糊匹配条件
   *
   * @param field 字段枚举
   * @param value 匹配值
   * @return 具体实现
   */
  C notLikeLeft(Enum<?> field, String value);

  /**
   * 非左模糊匹配条件
   *
   * @param tableAlias 字段表别名
   * @param field 字段枚举
   * @param value 匹配值
   * @return 具体实现
   */
  C notLikeLeft(String tableAlias, Enum<?> field, String value);

  /**
   * 非左模糊匹配条件
   *
   * @param condition 条件
   * @param field 字段名称
   * @param value 匹配值
   * @return 具体实现
   */
  default C notLikeLeft(boolean condition, String field, String value) {
    if (condition) {
      return this.notLikeLeft(field, value);
    }

    return (C) this;
  }

  /**
   * 非左模糊匹配条件
   *
   * @param condition 条件
   * @param field 字段枚举
   * @param value 匹配值
   * @return 具体实现
   */
  default C notLikeLeft(boolean condition, Enum<?> field, String value) {
    if (condition) {
      return this.notLikeLeft(field, value);
    }

    return (C) this;
  }

  /**
   * 非左模糊匹配条件
   *
   * @param condition 条件
   * @param tableAlias 字段表别名
   * @param field 字段枚举
   * @param value 匹配值
   * @return 具体实现
   */
  default C notLikeLeft(boolean condition, String tableAlias, Enum<?> field, String value) {
    if (condition) {
      return this.notLikeLeft(tableAlias, field, value);
    }

    return (C) this;
  }

  /**
   * 非右模糊匹配条件
   *
   * @param field 字段名称
   * @param value 匹配值
   * @return 具体实现
   */
  C notLikeRight(String field, String value);

  /**
   * 非右模糊匹配条件
   *
   * @param field 字段枚举
   * @param value 匹配值
   * @return 具体实现
   */
  C notLikeRight(Enum<?> field, String value);

  /**
   * 非右模糊匹配条件
   *
   * @param tableAlias 字段表别名
   * @param field 字段枚举
   * @param value 匹配值
   * @return 具体实现
   */
  C notLikeRight(String tableAlias, Enum<?> field, String value);

  /**
   * 非右模糊匹配条件
   *
   * @param condition 条件
   * @param field 字段名称
   * @param value 匹配值
   * @return 具体实现
   */
  default C notLikeRight(boolean condition, String field, String value) {
    if (condition) {
      return this.notLikeRight(field, value);
    }

    return (C) this;
  }

  /**
   * 非右模糊匹配条件
   *
   * @param condition 条件
   * @param field 字段枚举
   * @param value 匹配值
   * @return 具体实现
   */
  default C notLikeRight(boolean condition, Enum<?> field, String value) {
    if (condition) {
      return this.notLikeRight(field, value);
    }

    return (C) this;
  }

  /**
   * 非右模糊匹配条件
   *
   * @param condition 条件
   * @param tableAlias 字段表别名
   * @param field 字段枚举
   * @param value 匹配值
   * @return 具体实现
   */
  default C notLikeRight(boolean condition, String tableAlias, Enum<?> field, String value) {
    if (condition) {
      return this.notLikeRight(tableAlias, field, value);
    }

    return (C) this;
  }

  /**
   * 表达式匹配条件
   *
   * @param expression 表达式
   * @param args 表达式参数
   * @return 具体实现
   */
  C expression(String expression, Object... args);

  /**
   * 表达式匹配条件
   *
   * @param condition 条件
   * @param expression 表达式
   * @param args 表达式参数
   * @return 具体实现
   */
  default C expression(boolean condition, String expression, Object... args) {
    if (condition) {
      return this.expression(expression, args);
    }

    return (C) this;
  }

  /**
   * 嵌套条件
   *
   * @return 条件嵌套器
   */
  AbstractNestCondition<C> nest();

  /**
   * 开始或条件
   *
   * @return 或条件构建器
   */
  AbstractOrCondition<C> or();
}
